@omnia/fx 8.0.558-dev → 8.0.560-dev

package/internal-do-not-import-from-here/ux/velcron/editor/views/DefineVelcronEditorView.d.ts

@@ -0,0 +1,266 @@
+import { guid } from "@omnia/fx/models";
+import { EditorChromeView } from "@omnia/fx/ux/editor";
+export declare const defineVelcronEditorView: (param1: {
+    state: {
+        id: guid;
+        finishedLoading: boolean;
+        compactMode: boolean;
+        navigation: {
+            configuration: import("@omnia/fx/ux/editor").EditorChromeNavigationConfiguration;
+            enabled: boolean;
+            show: boolean;
+        };
+        drawers: {
+            right: {
+                panel: {
+                    settings: import("@omnia/fx/ux/editor").EditorChromePanel;
+                    show: boolean;
+                    actions: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                    footerToolbar: {
+                        actionsLeft: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                        actionsCenter: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                        actionsRight: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                        ExtendActionsRight: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                    };
+                };
+                canvas: {
+                    enabled: boolean;
+                    show: boolean;
+                    customScroll: boolean;
+                    header: {
+                        enabled: boolean;
+                        icon: import("@omnia/fx-models").IIcon;
+                        title: string;
+                    };
+                };
+            };
+        };
+        views: {
+            active: import("@omnia/fx/ux").EditorChromeViewRegistration;
+            registrations: import("@omnia/fx/ux").EditorChromeViewRegistration[];
+            history: {
+                items: {
+                    id: guid;
+                    timestamp: number;
+                }[];
+                currentIndex: number;
+                maxSize: number;
+            };
+        };
+        canvasSettings: {
+            scroll: {
+                store: {
+                    state: {
+                        elementRef: HTMLElement;
+                        elementId: string;
+                        disableScrolling: boolean;
+                        height: string;
+                        width: string;
+                        scrollingDirection: import("@omnia/fx-models").OScrollTypesCombination;
+                        coordinates: {
+                            readonly left: number;
+                            readonly right: number;
+                            readonly top: number;
+                            readonly bottom: number;
+                        };
+                    };
+                    events: import("../../../mobile").StoreEvents<{
+                        elementRef: HTMLElement;
+                        elementId: string;
+                        disableScrolling: boolean;
+                        height: string;
+                        width: string;
+                        scrollingDirection: import("@omnia/fx-models").OScrollTypesCombination;
+                        coordinates: {
+                            readonly left: number;
+                            readonly right: number;
+                            readonly top: number;
+                            readonly bottom: number;
+                        };
+                    }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+                    actions: import("../../../mobile").StoreReturnDefineAction<{
+                        scroll: () => void;
+                        setDisableScrolling: (disable: boolean) => void;
+                        calculateDynamicHeight: () => void;
+                        setHeight: (height: string) => void;
+                        setWidth: (width: string) => void;
+                        setScrolling: (scrolling: import("@omnia/fx-models").OScrollTypesCombination) => void;
+                        calculateScrollHeight: (referenceElementIds: string[]) => void;
+                        isElementNameStillInView: (elementName: string) => boolean;
+                        isElementIdStillInView: (elementId: string) => boolean;
+                        scrollToStart: () => void;
+                        scrollToElementId: (elementId: string, anchor?: import("@omnia/fx/ux").AnchorPosition, handler?: (target: HTMLElement, container: HTMLElement) => void, immediate?: boolean) => void;
+                        scrollToElementName: (elementName: string, anchor?: import("@omnia/fx/ux").AnchorPosition) => void;
+                        scrollToElement: (element: HTMLElement, anchor?: import("@omnia/fx/ux").AnchorPosition, handler?: (target: HTMLElement, container: HTMLElement) => void) => void;
+                        scrollToSelector: (selector: string, anchor?: import("@omnia/fx/ux").AnchorPosition, handler?: (target: HTMLElement, container: HTMLElement) => void, immediate?: boolean) => void;
+                    }>;
+                    get: {
+                        readonly coordinates: {
+                            readonly left: number;
+                            readonly right: number;
+                            readonly top: number;
+                            readonly bottom: number;
+                        };
+                        readonly scrollPosition: number;
+                    };
+                } & {
+                    dispose?: () => void;
+                };
+            };
+            zoom: {
+                enabled: boolean;
+                level: number;
+            };
+            displaySize: {
+                enabled: boolean;
+                value: "l" | "s" | "m";
+                store: {
+                    state: {
+                        width: string;
+                        zoomLevel: number;
+                    };
+                    events: import("../../../mobile").StoreEvents<{
+                        width: string;
+                        zoomLevel: number;
+                    }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+                    actions: import("../../../mobile").StoreReturnDefineAction<{
+                        setWidth: (width: string) => void;
+                        resetWidth: () => void;
+                        setBreakPoint: (breakPoint: import("@omnia/fx-models").DisplayBreakpointTypes) => void;
+                        resetZoomLevel: () => void;
+                        setZoomLevel: (zoomLevel: number) => void;
+                    }>;
+                    get: {};
+                } & {
+                    dispose?: () => void;
+                };
+            };
+        };
+        notificationMessage: {
+            key: guid;
+            message: string;
+            show: boolean;
+            timeout: number;
+            customRenderer: string;
+        };
+        operations: {
+            id: guid;
+            loading: boolean;
+        }[];
+    };
+    actions: import("../../../mobile").StoreReturnDefineAction<{
+        canvas: () => {
+            syncDisplaySettings: () => Promise<void>;
+            setDisplayBreakPoint: (value: import("@omnia/fx-models").DisplayBreakpointTypes) => void;
+            zoomIn: (step?: number) => void;
+            zoomOut: (step?: number) => void;
+            setZoom: (level: number) => void;
+            resetZoom: () => void;
+        };
+        editor: () => {
+            resetForNewActiveConfiguration: () => void;
+        };
+        views: () => {
+            register: (editorView: EditorChromeView | EditorChromeView[]) => void;
+            active: {
+                set: (view: EditorChromeView, addToHistory?: boolean) => void;
+                clear: () => void;
+                configuration: {
+                    set: (configuration: import("@omnia/fx/ux/editor").EditorChromeConfiguration) => void;
+                };
+            };
+            remove: (view: EditorChromeView) => void;
+            history: {
+                removeCurrent: () => void;
+                goBack: () => boolean;
+                goForward: () => boolean;
+                addToHistory: (view: EditorChromeView) => void;
+                clear: () => void;
+            };
+        };
+        showNotification: (message: import("@omnia/fx-models").NotificationMessage) => void;
+        operations: () => {
+            create: (showLoading?: boolean) => import("@omnia/fx-models").Future<null>;
+            setLoading: () => import("@omnia/fx-models").Future<null>;
+            register: (showLoading?: boolean) => guid;
+            unregister: (operationId: guid) => boolean;
+            clear: () => void;
+            waitForCompletion: () => Promise<void>;
+        };
+        navigation: () => {
+            register: (navigationItem: import("@omnia/fx/ux/editor").EditorChromeNavigationConfiguration) => void;
+            show: (value: boolean) => void;
+            toggle: () => void;
+        };
+        drawers: () => {
+            right: {
+                panel: {
+                    show: (panel: import("@omnia/fx/ux/editor").EditorChromePanel) => void;
+                    footerToolbar: {
+                        add: {
+                            action: (action: import("@omnia/fx/ux/editor").ChromeActionItem | import("@omnia/fx/ux/editor").ChromeActionItem[], position?: "left" | "center" | "right" | "extended-right") => void;
+                        };
+                    };
+                    close: () => void;
+                };
+                canvas: {
+                    configure: (header: {
+                        icon?: import("@omnia/fx-models").IIcon;
+                        title?: string;
+                        enabled?: boolean;
+                    }, customScroll?: boolean) => void;
+                    toolbar: {
+                        enable: (value: boolean) => void;
+                    };
+                    syncButtons: (currentId: guid) => void;
+                    toggle: () => void;
+                    show: (value: boolean) => void;
+                };
+            };
+        };
+        init: () => void;
+        dispose: () => void;
+    }>;
+    get: {
+        views: {
+            active: () => EditorChromeView;
+            all: () => EditorChromeView[];
+            byId: (id: guid) => EditorChromeView;
+        };
+        operations: {
+            all: () => guid[];
+            has: (operationId: guid) => boolean;
+            count: () => number;
+        };
+        history: () => {
+            view: EditorChromeView;
+            id: guid;
+            timestamp: number;
+        }[];
+    };
+    rules: {
+        showLoading: () => boolean;
+        history: {
+            canGoBack: () => boolean;
+            canGoForward: () => boolean;
+        };
+        views: {
+            hasActive: () => boolean;
+            active: {
+                configuration: {
+                    hasActive: () => boolean;
+                    hasBackgNavigation: () => boolean;
+                };
+            };
+        };
+    };
+    utils: {
+        configuration: {
+            extend: (target: import("@omnia/fx/ux/editor").EditorChromeConfiguration, configuration: import("@omnia/fx/ux/editor").EditorChromeConfiguration) => void;
+        };
+    };
+} & {
+    dispose?: () => void;
+}) => {
+    view: EditorChromeView;
+};

package/internal-do-not-import-from-here/ux/velcron/editor/views/DefineVelcronTemplatesConfig.d.ts

@@ -0,0 +1,357 @@
+import { guid } from "@omnia/fx-models";
+import { useEditorChromeStore } from "@omnia/fx/ux";
+import { EditorChromeConfiguration } from "@omnia/fx/ux/editor";
+export declare const defineVelcronTemplatesConfiguration: (param1: {
+    state: {
+        id: guid;
+        finishedLoading: boolean;
+        compactMode: boolean;
+        navigation: {
+            configuration: import("@omnia/fx/ux/editor").EditorChromeNavigationConfiguration;
+            enabled: boolean;
+            show: boolean;
+        };
+        drawers: {
+            right: {
+                panel: {
+                    settings: import("@omnia/fx/ux/editor").EditorChromePanel;
+                    show: boolean;
+                    actions: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                    footerToolbar: {
+                        actionsLeft: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                        actionsCenter: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                        actionsRight: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                        ExtendActionsRight: import("@omnia/fx/ux/editor").ChromeActionItem[];
+                    };
+                };
+                canvas: {
+                    enabled: boolean;
+                    show: boolean;
+                    customScroll: boolean;
+                    header: {
+                        enabled: boolean;
+                        icon: import("@omnia/fx-models").IIcon;
+                        title: string;
+                    };
+                };
+            };
+        };
+        views: {
+            active: import("@omnia/fx/ux").EditorChromeViewRegistration;
+            registrations: import("@omnia/fx/ux").EditorChromeViewRegistration[];
+            history: {
+                items: {
+                    id: guid;
+                    timestamp: number;
+                }[];
+                currentIndex: number;
+                maxSize: number;
+            };
+        };
+        canvasSettings: {
+            scroll: {
+                store: {
+                    state: {
+                        elementRef: HTMLElement;
+                        elementId: string;
+                        disableScrolling: boolean;
+                        height: string;
+                        width: string;
+                        scrollingDirection: import("@omnia/fx-models").OScrollTypesCombination;
+                        coordinates: {
+                            readonly left: number;
+                            readonly right: number;
+                            readonly top: number;
+                            readonly bottom: number;
+                        };
+                    };
+                    events: import("../../../mobile").StoreEvents<{
+                        elementRef: HTMLElement;
+                        elementId: string;
+                        disableScrolling: boolean;
+                        height: string;
+                        width: string;
+                        scrollingDirection: import("@omnia/fx-models").OScrollTypesCombination;
+                        coordinates: {
+                            readonly left: number;
+                            readonly right: number;
+                            readonly top: number;
+                            readonly bottom: number;
+                        };
+                    }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+                    actions: import("../../../mobile").StoreReturnDefineAction<{
+                        scroll: () => void;
+                        setDisableScrolling: (disable: boolean) => void;
+                        calculateDynamicHeight: () => void;
+                        setHeight: (height: string) => void;
+                        setWidth: (width: string) => void;
+                        setScrolling: (scrolling: import("@omnia/fx-models").OScrollTypesCombination) => void;
+                        calculateScrollHeight: (referenceElementIds: string[]) => void;
+                        isElementNameStillInView: (elementName: string) => boolean;
+                        isElementIdStillInView: (elementId: string) => boolean;
+                        scrollToStart: () => void;
+                        scrollToElementId: (elementId: string, anchor?: import("@omnia/fx/ux").AnchorPosition, handler?: (target: HTMLElement, container: HTMLElement) => void, immediate?: boolean) => void;
+                        scrollToElementName: (elementName: string, anchor?: import("@omnia/fx/ux").AnchorPosition) => void;
+                        scrollToElement: (element: HTMLElement, anchor?: import("@omnia/fx/ux").AnchorPosition, handler?: (target: HTMLElement, container: HTMLElement) => void) => void;
+                        scrollToSelector: (selector: string, anchor?: import("@omnia/fx/ux").AnchorPosition, handler?: (target: HTMLElement, container: HTMLElement) => void, immediate?: boolean) => void;
+                    }>;
+                    get: {
+                        readonly coordinates: {
+                            readonly left: number;
+                            readonly right: number;
+                            readonly top: number;
+                            readonly bottom: number;
+                        };
+                        readonly scrollPosition: number;
+                    };
+                } & {
+                    dispose?: () => void;
+                };
+            };
+            zoom: {
+                enabled: boolean;
+                level: number;
+            };
+            displaySize: {
+                enabled: boolean;
+                value: "l" | "s" | "m";
+                store: {
+                    state: {
+                        width: string;
+                        zoomLevel: number;
+                    };
+                    events: import("../../../mobile").StoreEvents<{
+                        width: string;
+                        zoomLevel: number;
+                    }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+                    actions: import("../../../mobile").StoreReturnDefineAction<{
+                        setWidth: (width: string) => void;
+                        resetWidth: () => void;
+                        setBreakPoint: (breakPoint: import("@omnia/fx-models").DisplayBreakpointTypes) => void;
+                        resetZoomLevel: () => void;
+                        setZoomLevel: (zoomLevel: number) => void;
+                    }>;
+                    get: {};
+                } & {
+                    dispose?: () => void;
+                };
+            };
+        };
+        notificationMessage: {
+            key: guid;
+            message: string;
+            show: boolean;
+            timeout: number;
+            customRenderer: string;
+        };
+        operations: {
+            id: guid;
+            loading: boolean;
+        }[];
+    };
+    actions: import("../../../mobile").StoreReturnDefineAction<{
+        canvas: () => {
+            syncDisplaySettings: () => Promise<void>;
+            setDisplayBreakPoint: (value: import("@omnia/fx-models").DisplayBreakpointTypes) => void;
+            zoomIn: (step?: number) => void;
+            zoomOut: (step?: number) => void;
+            setZoom: (level: number) => void;
+            resetZoom: () => void;
+        };
+        editor: () => {
+            resetForNewActiveConfiguration: () => void;
+        };
+        views: () => {
+            register: (editorView: import("@omnia/fx/ux/editor").EditorChromeView | import("@omnia/fx/ux/editor").EditorChromeView[]) => void;
+            active: {
+                set: (view: import("@omnia/fx/ux/editor").EditorChromeView, addToHistory?: boolean) => void;
+                clear: () => void;
+                configuration: {
+                    set: (configuration: EditorChromeConfiguration) => void;
+                };
+            };
+            remove: (view: import("@omnia/fx/ux/editor").EditorChromeView) => void;
+            history: {
+                removeCurrent: () => void;
+                goBack: () => boolean;
+                goForward: () => boolean;
+                addToHistory: (view: import("@omnia/fx/ux/editor").EditorChromeView) => void;
+                clear: () => void;
+            };
+        };
+        showNotification: (message: import("@omnia/fx-models").NotificationMessage) => void;
+        operations: () => {
+            create: (showLoading?: boolean) => import("@omnia/fx-models").Future<null>;
+            setLoading: () => import("@omnia/fx-models").Future<null>;
+            register: (showLoading?: boolean) => guid;
+            unregister: (operationId: guid) => boolean;
+            clear: () => void;
+            waitForCompletion: () => Promise<void>;
+        };
+        navigation: () => {
+            register: (navigationItem: import("@omnia/fx/ux/editor").EditorChromeNavigationConfiguration) => void;
+            show: (value: boolean) => void;
+            toggle: () => void;
+        };
+        drawers: () => {
+            right: {
+                panel: {
+                    show: (panel: import("@omnia/fx/ux/editor").EditorChromePanel) => void;
+                    footerToolbar: {
+                        add: {
+                            action: (action: import("@omnia/fx/ux/editor").ChromeActionItem | import("@omnia/fx/ux/editor").ChromeActionItem[], position?: "left" | "center" | "right" | "extended-right") => void;
+                        };
+                    };
+                    close: () => void;
+                };
+                canvas: {
+                    configure: (header: {
+                        icon?: import("@omnia/fx-models").IIcon;
+                        title?: string;
+                        enabled?: boolean;
+                    }, customScroll?: boolean) => void;
+                    toolbar: {
+                        enable: (value: boolean) => void;
+                    };
+                    syncButtons: (currentId: guid) => void;
+                    toggle: () => void;
+                    show: (value: boolean) => void;
+                };
+            };
+        };
+        init: () => void;
+        dispose: () => void;
+    }>;
+    get: {
+        views: {
+            active: () => import("@omnia/fx/ux/editor").EditorChromeView;
+            all: () => import("@omnia/fx/ux/editor").EditorChromeView[];
+            byId: (id: guid) => import("@omnia/fx/ux/editor").EditorChromeView;
+        };
+        operations: {
+            all: () => guid[];
+            has: (operationId: guid) => boolean;
+            count: () => number;
+        };
+        history: () => {
+            view: import("@omnia/fx/ux/editor").EditorChromeView;
+            id: guid;
+            timestamp: number;
+        }[];
+    };
+    rules: {
+        showLoading: () => boolean;
+        history: {
+            canGoBack: () => boolean;
+            canGoForward: () => boolean;
+        };
+        views: {
+            hasActive: () => boolean;
+            active: {
+                configuration: {
+                    hasActive: () => boolean;
+                    hasBackgNavigation: () => boolean;
+                };
+            };
+        };
+    };
+    utils: {
+        configuration: {
+            extend: (target: EditorChromeConfiguration, configuration: EditorChromeConfiguration) => void;
+        };
+    };
+} & {
+    dispose?: () => void;
+}, param2: {
+    state: {
+        editing: {
+            definition: import("@omnia/fx-models").VelcronAppDefinition<object>;
+        };
+        source: {
+            editMode: import("../store").CodeViewMode;
+            json: {
+                app: string;
+                appState: string;
+                appBody: string;
+                appEditors: string;
+            };
+        };
+        drawerMode: "settings" | "picker" | "definition-structure" | "code-editor";
+        selection: {
+            item: import("@omnia/fx-models").VelcronDefinition;
+        };
+        settings: {
+            colorSchemaType: string;
+            canvasMode: {
+                current: "preview" | "design";
+                previous: "preview" | "design";
+            };
+        };
+    };
+    events: import("../../../mobile").StoreEvents<{
+        editing: {
+            definition: import("@omnia/fx-models").VelcronAppDefinition<object>;
+        };
+        source: {
+            editMode: import("../store").CodeViewMode;
+            json: {
+                app: string;
+                appState: string;
+                appBody: string;
+                appEditors: string;
+            };
+        };
+        drawerMode: "settings" | "picker" | "definition-structure" | "code-editor";
+        selection: {
+            item: import("@omnia/fx-models").VelcronDefinition;
+        };
+        settings: {
+            colorSchemaType: string;
+            canvasMode: {
+                current: "preview" | "design";
+                previous: "preview" | "design";
+            };
+        };
+    }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+    actions: import("../../../mobile").StoreReturnDefineAction<{
+        editor: () => import("../../../mobile").StoreReturnDefineAction<{
+            selectItem: (item: import("@omnia/fx-models").VelcronDefinition) => void;
+        }>;
+        show: () => import("../../../mobile").StoreReturnDefineAction<{
+            sourcePanel: (action: "show" | "hide" | "toggle") => void;
+            settingsPanel: (action: "show" | "hide" | "toggle") => void;
+        }>;
+        canvas: () => import("../../../mobile").StoreReturnDefineAction<{
+            setMode: (mode: "preview" | "design") => void;
+        }>;
+        template: () => import("../../../mobile").StoreReturnDefineAction<{
+            update: () => {
+                byJson: (json: string) => void;
+            };
+            edit: () => {
+                byResolverReference: (ref: import("@omnia/fx-models").VelcronRendererResolverReference) => void;
+                definition: (definition: import("@omnia/fx-models").VelcronAppDefinition) => void;
+            };
+        }>;
+        init: (editorChromeStoreRef: ReturnType<typeof useEditorChromeStore>) => void;
+    }>;
+    get: {
+        ready: () => import("@omnia/fx-models").Future<void>;
+        canvas: {
+            mode: () => "preview" | "design";
+        };
+    };
+    rules: {
+        is: {
+            selected: (item: import("@omnia/fx-models").VelcronDefinition) => boolean;
+            editorEmpty: () => boolean;
+            settingsActive: () => boolean;
+            codeEditorActive: () => boolean;
+        };
+    };
+} & {
+    dispose?: () => void;
+}) => {
+    configuration: EditorChromeConfiguration;
+    refresh(): void;
+};

package/internal-do-not-import-from-here/ux/velcron/editor/views/index.d.ts

@@ -0,0 +1 @@
+export * from "./DefineVelcronEditorView";

package/internal-do-not-import-from-here/ux/velcron/editor_old/VelcronEditor.d.ts

@@ -0,0 +1,27 @@
+import { DefineEmit, DefineSlot } from "@omnia/fx/ux";
+import { VNodeChild } from "vue";
+import { VelcronAppDefinition } from "@omnia/fx-models";
+export type DefinitionChanged = (definition: VelcronAppDefinition) => void;
+declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
+    "emit:update:modelValue": (value: boolean) => void;
+} & {
+    "v-model"?: boolean;
+} & {
+    modelValue?: boolean;
+} & {
+    definition?: VelcronAppDefinition<object>;
+} & {
+    mode?: "store" | "return";
+} & DefineEmit<"click:close", () => true> & DefineEmit<"save", (definition: VelcronAppDefinition) => true> & DefineSlot<"activator", () => VNodeChild>> & {
+    "onUpdate:modelValue"?: (value: boolean) => any;
+    "onClick:close"?: () => any;
+    onSave?: (definition: VelcronAppDefinition<object>) => any;
+} & {
+    "v-slots"?: {
+        activator?: () => VNodeChild;
+    } & Omit<{
+        default?: import("vue").Slot;
+        $stable?: boolean;
+    }, "activator">;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "mode" | "definition" | "v-model" | "modelValue" | "emit:update:modelValue" | "slot:activator" | "emit:click:close" | "emit:save"> & import("@omnia/fx/ux").VNodeEvents) => any;
+export default _default;

package/internal-do-not-import-from-here/ux/velcron/editor_old/components/panels/edit-component/StylingPanel.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{}>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{}>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {}>, never>;
+};
+export default _default;