@omnia/fx 8.0.26-vnext → 8.0.28-vnext
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/internal-do-not-import-from-here/manifests/omfx.libs.prosemirror.manifest.json +1 -1
 - package/internal-do-not-import-from-here/ux/appprovisioning/appprovisioningwizard/AppProvisioningWizard.d.ts +2 -2
 - package/internal-do-not-import-from-here/ux/layoutcanvas/stores/VelcronDefinitionStore.d.ts +4 -4
 - package/internal-do-not-import-from-here/ux/layoutcanvas/velcron_definitions/blockheaders.d.ts +2 -2
 - package/internal-do-not-import-from-here/ux/layoutcanvas/velcron_definitions/contentblocks.d.ts +3 -3
 - package/internal-do-not-import-from-here/ux/markdown/MarkdownEditor.css.d.ts +5 -0
 - package/internal-do-not-import-from-here/ux/markdown/MarkdownEditor.d.ts +28 -0
 - package/internal-do-not-import-from-here/ux/markdown/MarkdownRenderer.d.ts +1 -0
 - package/internal-do-not-import-from-here/ux/oxide/btn/Button.d.ts +17 -0
 - package/internal-do-not-import-from-here/ux/oxide/btngroup/ButtonGroup.d.ts +101 -0
 - package/internal-do-not-import-from-here/ux/oxide/menu/Menu.d.ts +17 -0
 - package/internal-do-not-import-from-here/ux/oxide/stepper/Stepper.d.ts +69 -62
 - package/internal-do-not-import-from-here/ux/oxide/stepper/StepperStep.d.ts +90 -61
 - package/internal-do-not-import-from-here/ux/use/UseBreakPoint.d.ts +2 -1
 - package/internal-do-not-import-from-here/ux/use/UseColorSchemaSetup.d.ts +1 -73
 - package/internal-do-not-import-from-here/ux/velcron/blocks/content/ContentBlock.css.d.ts +7 -1
 - package/internal-do-not-import-from-here/ux/velcron/blocks/content/ContentBlock.d.ts +6 -0
 - package/internal-do-not-import-from-here/ux/velcron/blocks/content/components/ContentViewer.css.d.ts +6 -0
 - package/internal-do-not-import-from-here/ux/velcron/blocks/content/components/ContentViewer.d.ts +94 -0
 - package/internal-do-not-import-from-here/ux/velcron/blocks/content/components/{DefinitionPickerPanelStyles.d.ts → DefinitionPickerPanel.css.d.ts} +1 -0
 - package/internal-do-not-import-from-here/ux/velcron/blocks/content/components/DefinitionPickerPanel.d.ts +72 -19
 - package/internal-do-not-import-from-here/ux/velcron/blocks/content/model/ContentDefinitionRegistration.d.ts +5 -0
 - package/internal-do-not-import-from-here/ux/velcron/blocks/content/store/ContentBlockStore.d.ts +40 -0
 - package/internal-do-not-import-from-here/ux/velcron/blocks/velcron/VelcronBlockSettings.d.ts +7 -2
 - package/internal-do-not-import-from-here/ux/velcron/components/properties/VelcronProperties.d.ts +96 -96
 - package/internal-do-not-import-from-here/ux/velcron/core/index.d.ts +1 -0
 - package/internal-do-not-import-from-here/ux/velcron/core/models/VelcronDefinitions.d.ts +20 -17
 - package/internal-do-not-import-from-here/ux/velcron/core/models/VelcronEvents.d.ts +3 -0
 - package/internal-do-not-import-from-here/ux/velcron/core/parser/VelcronRenderers.d.ts +3 -91
 - package/internal-do-not-import-from-here/ux/velcron/core/rules/IsEditMode.d.ts +20 -0
 - package/internal-do-not-import-from-here/ux/velcron/core/rules/index.d.ts +1 -0
 - package/internal-do-not-import-from-here/ux/velcron/editor/VelcronEditor.d.ts +156 -156
 - package/internal-do-not-import-from-here/ux/velcron/editor/components/pickers/colorschemamapper/ColorSchemaMapper.d.ts +16 -11
 - package/internal-do-not-import-from-here/ux/velcron/editor/stores/VelcronEditorStore.d.ts +3 -3
 - package/internal-do-not-import-from-here/ux/velcron/renderer/VelcronRenderer.d.ts +52 -12
 - package/internal-do-not-import-from-here/ux/velcron/renderer/components/App.d.ts +5 -5
 - package/internal-do-not-import-from-here/ux/wizard/IWizard.d.ts +1 -1
 - package/internal-do-not-import-from-here/ux/wizard/WizardComponent.d.ts +2 -2
 - package/internal-do-not-import-from-here/wctypings.d.ts +2 -0
 - package/package.json +2 -2
 - package/internal-do-not-import-from-here/ux/markdown/Toast.d.ts +0 -4
 
    
        package/internal-do-not-import-from-here/ux/velcron/components/properties/VelcronProperties.d.ts
    CHANGED
    
    | 
         @@ -11,73 +11,73 @@ declare const _default: { 
     | 
|
| 
       11 
11 
     | 
    
         
             
                            type: import("vue").PropType<VelcronDefinitionEditableProperty[]>;
         
     | 
| 
       12 
12 
     | 
    
         
             
                        };
         
     | 
| 
       13 
13 
     | 
    
         
             
                        "onUpdate:modelValue": {
         
     | 
| 
       14 
     | 
    
         
            -
                            type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 14 
     | 
    
         
            +
                            type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       15 
15 
     | 
    
         
             
                        };
         
     | 
| 
       16 
16 
     | 
    
         
             
                        "v-model": {
         
     | 
| 
       17 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 17 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       18 
18 
     | 
    
         
             
                            required: false;
         
     | 
| 
       19 
19 
     | 
    
         
             
                        };
         
     | 
| 
       20 
20 
     | 
    
         
             
                        modelValue: {
         
     | 
| 
       21 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 21 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       22 
22 
     | 
    
         
             
                            required: false;
         
     | 
| 
       23 
23 
     | 
    
         
             
                        };
         
     | 
| 
       24 
24 
     | 
    
         
             
                        name: <TName extends string>(n?: TName) => { [key in import("../../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
         
     | 
| 
       25 
     | 
    
         
            -
                            type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 25 
     | 
    
         
            +
                            type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       26 
26 
     | 
    
         
             
                        }; } & { [key_1 in import("../../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
         
     | 
| 
       27 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 27 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       28 
28 
     | 
    
         
             
                            required: false;
         
     | 
| 
       29 
29 
     | 
    
         
             
                        }; } & { [key_2 in import("../../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
         
     | 
| 
       30 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 30 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       31 
31 
     | 
    
         
             
                            required: false;
         
     | 
| 
       32 
32 
     | 
    
         
             
                        }; } & {
         
     | 
| 
       33 
     | 
    
         
            -
                            require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, VelcronAppDefinition 
     | 
| 
      
 33 
     | 
    
         
            +
                            require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, VelcronAppDefinition<object>, {
         
     | 
| 
       34 
34 
     | 
    
         
             
                                "onUpdate:modelValue": {
         
     | 
| 
       35 
     | 
    
         
            -
                                    type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 35 
     | 
    
         
            +
                                    type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       36 
36 
     | 
    
         
             
                                };
         
     | 
| 
       37 
37 
     | 
    
         
             
                            } & {
         
     | 
| 
       38 
38 
     | 
    
         
             
                                "v-model": {
         
     | 
| 
       39 
     | 
    
         
            -
                                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 39 
     | 
    
         
            +
                                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       40 
40 
     | 
    
         
             
                                    required: false;
         
     | 
| 
       41 
41 
     | 
    
         
             
                                };
         
     | 
| 
       42 
42 
     | 
    
         
             
                            } & {
         
     | 
| 
       43 
43 
     | 
    
         
             
                                modelValue: {
         
     | 
| 
       44 
     | 
    
         
            -
                                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 44 
     | 
    
         
            +
                                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       45 
45 
     | 
    
         
             
                                    required: false;
         
     | 
| 
       46 
46 
     | 
    
         
             
                                };
         
     | 
| 
       47 
47 
     | 
    
         
             
                            }>;
         
     | 
| 
       48 
     | 
    
         
            -
                            defaultValue(value?: VelcronAppDefinition): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, VelcronAppDefinition 
     | 
| 
      
 48 
     | 
    
         
            +
                            defaultValue(value?: VelcronAppDefinition<object>): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, VelcronAppDefinition<object>, {
         
     | 
| 
       49 
49 
     | 
    
         
             
                                "onUpdate:modelValue": {
         
     | 
| 
       50 
     | 
    
         
            -
                                    type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 50 
     | 
    
         
            +
                                    type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       51 
51 
     | 
    
         
             
                                };
         
     | 
| 
       52 
52 
     | 
    
         
             
                            } & {
         
     | 
| 
       53 
53 
     | 
    
         
             
                                "v-model": {
         
     | 
| 
       54 
     | 
    
         
            -
                                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 54 
     | 
    
         
            +
                                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       55 
55 
     | 
    
         
             
                                    required: false;
         
     | 
| 
       56 
56 
     | 
    
         
             
                                };
         
     | 
| 
       57 
57 
     | 
    
         
             
                            } & {
         
     | 
| 
       58 
58 
     | 
    
         
             
                                modelValue: {
         
     | 
| 
       59 
     | 
    
         
            -
                                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 59 
     | 
    
         
            +
                                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       60 
60 
     | 
    
         
             
                                    required: false;
         
     | 
| 
       61 
61 
     | 
    
         
             
                                };
         
     | 
| 
       62 
62 
     | 
    
         
             
                            }, false>;
         
     | 
| 
       63 
     | 
    
         
            -
                            doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, VelcronAppDefinition 
     | 
| 
      
 63 
     | 
    
         
            +
                            doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, VelcronAppDefinition<object>, {
         
     | 
| 
       64 
64 
     | 
    
         
             
                                "onUpdate:modelValue": {
         
     | 
| 
       65 
     | 
    
         
            -
                                    type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 65 
     | 
    
         
            +
                                    type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       66 
66 
     | 
    
         
             
                                };
         
     | 
| 
       67 
67 
     | 
    
         
             
                            } & {
         
     | 
| 
       68 
68 
     | 
    
         
             
                                "v-model": {
         
     | 
| 
       69 
     | 
    
         
            -
                                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 69 
     | 
    
         
            +
                                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       70 
70 
     | 
    
         
             
                                    required: false;
         
     | 
| 
       71 
71 
     | 
    
         
             
                                };
         
     | 
| 
       72 
72 
     | 
    
         
             
                            } & {
         
     | 
| 
       73 
73 
     | 
    
         
             
                                modelValue: {
         
     | 
| 
       74 
     | 
    
         
            -
                                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 74 
     | 
    
         
            +
                                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       75 
75 
     | 
    
         
             
                                    required: false;
         
     | 
| 
       76 
76 
     | 
    
         
             
                                };
         
     | 
| 
       77 
77 
     | 
    
         
             
                            }>;
         
     | 
| 
       78 
78 
     | 
    
         
             
                        };
         
     | 
| 
       79 
79 
     | 
    
         
             
                    }>> & {
         
     | 
| 
       80 
     | 
    
         
            -
                        "onUpdate:modelValue"?: (value: VelcronAppDefinition) => any;
         
     | 
| 
      
 80 
     | 
    
         
            +
                        "onUpdate:modelValue"?: (value: VelcronAppDefinition<object>) => any;
         
     | 
| 
       81 
81 
     | 
    
         
             
                    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
         
     | 
| 
       82 
82 
     | 
    
         
             
                    $attrs: {
         
     | 
| 
       83 
83 
     | 
    
         
             
                        [x: string]: unknown;
         
     | 
| 
         @@ -90,7 +90,7 @@ declare const _default: { 
     | 
|
| 
       90 
90 
     | 
    
         
             
                    }>;
         
     | 
| 
       91 
91 
     | 
    
         
             
                    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
         
     | 
| 
       92 
92 
     | 
    
         
             
                    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
         
     | 
| 
       93 
     | 
    
         
            -
                    $emit: (event: "update:modelValue", value: VelcronAppDefinition) => void;
         
     | 
| 
      
 93 
     | 
    
         
            +
                    $emit: (event: "update:modelValue", value: VelcronAppDefinition<object>) => void;
         
     | 
| 
       94 
94 
     | 
    
         
             
                    $el: any;
         
     | 
| 
       95 
95 
     | 
    
         
             
                    $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
         
     | 
| 
       96 
96 
     | 
    
         
             
                        properties: {
         
     | 
| 
         @@ -99,73 +99,73 @@ declare const _default: { 
     | 
|
| 
       99 
99 
     | 
    
         
             
                            type: import("vue").PropType<VelcronDefinitionEditableProperty[]>;
         
     | 
| 
       100 
100 
     | 
    
         
             
                        };
         
     | 
| 
       101 
101 
     | 
    
         
             
                        "onUpdate:modelValue": {
         
     | 
| 
       102 
     | 
    
         
            -
                            type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 102 
     | 
    
         
            +
                            type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       103 
103 
     | 
    
         
             
                        };
         
     | 
| 
       104 
104 
     | 
    
         
             
                        "v-model": {
         
     | 
| 
       105 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 105 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       106 
106 
     | 
    
         
             
                            required: false;
         
     | 
| 
       107 
107 
     | 
    
         
             
                        };
         
     | 
| 
       108 
108 
     | 
    
         
             
                        modelValue: {
         
     | 
| 
       109 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 109 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       110 
110 
     | 
    
         
             
                            required: false;
         
     | 
| 
       111 
111 
     | 
    
         
             
                        };
         
     | 
| 
       112 
112 
     | 
    
         
             
                        name: <TName extends string>(n?: TName) => { [key in import("../../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
         
     | 
| 
       113 
     | 
    
         
            -
                            type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 113 
     | 
    
         
            +
                            type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       114 
114 
     | 
    
         
             
                        }; } & { [key_1 in import("../../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
         
     | 
| 
       115 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 115 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       116 
116 
     | 
    
         
             
                            required: false;
         
     | 
| 
       117 
117 
     | 
    
         
             
                        }; } & { [key_2 in import("../../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
         
     | 
| 
       118 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 118 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       119 
119 
     | 
    
         
             
                            required: false;
         
     | 
| 
       120 
120 
     | 
    
         
             
                        }; } & {
         
     | 
| 
       121 
     | 
    
         
            -
                            require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, VelcronAppDefinition 
     | 
| 
      
 121 
     | 
    
         
            +
                            require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, VelcronAppDefinition<object>, {
         
     | 
| 
       122 
122 
     | 
    
         
             
                                "onUpdate:modelValue": {
         
     | 
| 
       123 
     | 
    
         
            -
                                    type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 123 
     | 
    
         
            +
                                    type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       124 
124 
     | 
    
         
             
                                };
         
     | 
| 
       125 
125 
     | 
    
         
             
                            } & {
         
     | 
| 
       126 
126 
     | 
    
         
             
                                "v-model": {
         
     | 
| 
       127 
     | 
    
         
            -
                                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 127 
     | 
    
         
            +
                                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       128 
128 
     | 
    
         
             
                                    required: false;
         
     | 
| 
       129 
129 
     | 
    
         
             
                                };
         
     | 
| 
       130 
130 
     | 
    
         
             
                            } & {
         
     | 
| 
       131 
131 
     | 
    
         
             
                                modelValue: {
         
     | 
| 
       132 
     | 
    
         
            -
                                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 132 
     | 
    
         
            +
                                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       133 
133 
     | 
    
         
             
                                    required: false;
         
     | 
| 
       134 
134 
     | 
    
         
             
                                };
         
     | 
| 
       135 
135 
     | 
    
         
             
                            }>;
         
     | 
| 
       136 
     | 
    
         
            -
                            defaultValue(value?: VelcronAppDefinition): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, VelcronAppDefinition 
     | 
| 
      
 136 
     | 
    
         
            +
                            defaultValue(value?: VelcronAppDefinition<object>): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, VelcronAppDefinition<object>, {
         
     | 
| 
       137 
137 
     | 
    
         
             
                                "onUpdate:modelValue": {
         
     | 
| 
       138 
     | 
    
         
            -
                                    type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 138 
     | 
    
         
            +
                                    type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       139 
139 
     | 
    
         
             
                                };
         
     | 
| 
       140 
140 
     | 
    
         
             
                            } & {
         
     | 
| 
       141 
141 
     | 
    
         
             
                                "v-model": {
         
     | 
| 
       142 
     | 
    
         
            -
                                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 142 
     | 
    
         
            +
                                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       143 
143 
     | 
    
         
             
                                    required: false;
         
     | 
| 
       144 
144 
     | 
    
         
             
                                };
         
     | 
| 
       145 
145 
     | 
    
         
             
                            } & {
         
     | 
| 
       146 
146 
     | 
    
         
             
                                modelValue: {
         
     | 
| 
       147 
     | 
    
         
            -
                                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 147 
     | 
    
         
            +
                                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       148 
148 
     | 
    
         
             
                                    required: false;
         
     | 
| 
       149 
149 
     | 
    
         
             
                                };
         
     | 
| 
       150 
150 
     | 
    
         
             
                            }, false>;
         
     | 
| 
       151 
     | 
    
         
            -
                            doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, VelcronAppDefinition 
     | 
| 
      
 151 
     | 
    
         
            +
                            doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, VelcronAppDefinition<object>, {
         
     | 
| 
       152 
152 
     | 
    
         
             
                                "onUpdate:modelValue": {
         
     | 
| 
       153 
     | 
    
         
            -
                                    type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 153 
     | 
    
         
            +
                                    type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       154 
154 
     | 
    
         
             
                                };
         
     | 
| 
       155 
155 
     | 
    
         
             
                            } & {
         
     | 
| 
       156 
156 
     | 
    
         
             
                                "v-model": {
         
     | 
| 
       157 
     | 
    
         
            -
                                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 157 
     | 
    
         
            +
                                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       158 
158 
     | 
    
         
             
                                    required: false;
         
     | 
| 
       159 
159 
     | 
    
         
             
                                };
         
     | 
| 
       160 
160 
     | 
    
         
             
                            } & {
         
     | 
| 
       161 
161 
     | 
    
         
             
                                modelValue: {
         
     | 
| 
       162 
     | 
    
         
            -
                                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 162 
     | 
    
         
            +
                                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       163 
163 
     | 
    
         
             
                                    required: false;
         
     | 
| 
       164 
164 
     | 
    
         
             
                                };
         
     | 
| 
       165 
165 
     | 
    
         
             
                            }>;
         
     | 
| 
       166 
166 
     | 
    
         
             
                        };
         
     | 
| 
       167 
167 
     | 
    
         
             
                    }>> & {
         
     | 
| 
       168 
     | 
    
         
            -
                        "onUpdate:modelValue"?: (value: VelcronAppDefinition) => any;
         
     | 
| 
      
 168 
     | 
    
         
            +
                        "onUpdate:modelValue"?: (value: VelcronAppDefinition<object>) => any;
         
     | 
| 
       169 
169 
     | 
    
         
             
                    }, () => JSX.Element[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
         
     | 
| 
       170 
170 
     | 
    
         
             
                        "update:modelValue": (value: VelcronAppDefinition) => true;
         
     | 
| 
       171 
171 
     | 
    
         
             
                    }, string, {}, {}, string> & {
         
     | 
| 
         @@ -195,73 +195,73 @@ declare const _default: { 
     | 
|
| 
       195 
195 
     | 
    
         
             
                        type: import("vue").PropType<VelcronDefinitionEditableProperty[]>;
         
     | 
| 
       196 
196 
     | 
    
         
             
                    };
         
     | 
| 
       197 
197 
     | 
    
         
             
                    "onUpdate:modelValue": {
         
     | 
| 
       198 
     | 
    
         
            -
                        type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 198 
     | 
    
         
            +
                        type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       199 
199 
     | 
    
         
             
                    };
         
     | 
| 
       200 
200 
     | 
    
         
             
                    "v-model": {
         
     | 
| 
       201 
     | 
    
         
            -
                        type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 201 
     | 
    
         
            +
                        type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       202 
202 
     | 
    
         
             
                        required: false;
         
     | 
| 
       203 
203 
     | 
    
         
             
                    };
         
     | 
| 
       204 
204 
     | 
    
         
             
                    modelValue: {
         
     | 
| 
       205 
     | 
    
         
            -
                        type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 205 
     | 
    
         
            +
                        type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       206 
206 
     | 
    
         
             
                        required: false;
         
     | 
| 
       207 
207 
     | 
    
         
             
                    };
         
     | 
| 
       208 
208 
     | 
    
         
             
                    name: <TName extends string>(n?: TName) => { [key in import("../../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
         
     | 
| 
       209 
     | 
    
         
            -
                        type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 209 
     | 
    
         
            +
                        type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       210 
210 
     | 
    
         
             
                    }; } & { [key_1 in import("../../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
         
     | 
| 
       211 
     | 
    
         
            -
                        type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 211 
     | 
    
         
            +
                        type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       212 
212 
     | 
    
         
             
                        required: false;
         
     | 
| 
       213 
213 
     | 
    
         
             
                    }; } & { [key_2 in import("../../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
         
     | 
| 
       214 
     | 
    
         
            -
                        type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 214 
     | 
    
         
            +
                        type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       215 
215 
     | 
    
         
             
                        required: false;
         
     | 
| 
       216 
216 
     | 
    
         
             
                    }; } & {
         
     | 
| 
       217 
     | 
    
         
            -
                        require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, VelcronAppDefinition 
     | 
| 
      
 217 
     | 
    
         
            +
                        require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, VelcronAppDefinition<object>, {
         
     | 
| 
       218 
218 
     | 
    
         
             
                            "onUpdate:modelValue": {
         
     | 
| 
       219 
     | 
    
         
            -
                                type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 219 
     | 
    
         
            +
                                type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       220 
220 
     | 
    
         
             
                            };
         
     | 
| 
       221 
221 
     | 
    
         
             
                        } & {
         
     | 
| 
       222 
222 
     | 
    
         
             
                            "v-model": {
         
     | 
| 
       223 
     | 
    
         
            -
                                type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 223 
     | 
    
         
            +
                                type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       224 
224 
     | 
    
         
             
                                required: false;
         
     | 
| 
       225 
225 
     | 
    
         
             
                            };
         
     | 
| 
       226 
226 
     | 
    
         
             
                        } & {
         
     | 
| 
       227 
227 
     | 
    
         
             
                            modelValue: {
         
     | 
| 
       228 
     | 
    
         
            -
                                type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 228 
     | 
    
         
            +
                                type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       229 
229 
     | 
    
         
             
                                required: false;
         
     | 
| 
       230 
230 
     | 
    
         
             
                            };
         
     | 
| 
       231 
231 
     | 
    
         
             
                        }>;
         
     | 
| 
       232 
     | 
    
         
            -
                        defaultValue(value?: VelcronAppDefinition): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, VelcronAppDefinition 
     | 
| 
      
 232 
     | 
    
         
            +
                        defaultValue(value?: VelcronAppDefinition<object>): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, VelcronAppDefinition<object>, {
         
     | 
| 
       233 
233 
     | 
    
         
             
                            "onUpdate:modelValue": {
         
     | 
| 
       234 
     | 
    
         
            -
                                type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 234 
     | 
    
         
            +
                                type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       235 
235 
     | 
    
         
             
                            };
         
     | 
| 
       236 
236 
     | 
    
         
             
                        } & {
         
     | 
| 
       237 
237 
     | 
    
         
             
                            "v-model": {
         
     | 
| 
       238 
     | 
    
         
            -
                                type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 238 
     | 
    
         
            +
                                type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       239 
239 
     | 
    
         
             
                                required: false;
         
     | 
| 
       240 
240 
     | 
    
         
             
                            };
         
     | 
| 
       241 
241 
     | 
    
         
             
                        } & {
         
     | 
| 
       242 
242 
     | 
    
         
             
                            modelValue: {
         
     | 
| 
       243 
     | 
    
         
            -
                                type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 243 
     | 
    
         
            +
                                type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       244 
244 
     | 
    
         
             
                                required: false;
         
     | 
| 
       245 
245 
     | 
    
         
             
                            };
         
     | 
| 
       246 
246 
     | 
    
         
             
                        }, false>;
         
     | 
| 
       247 
     | 
    
         
            -
                        doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, VelcronAppDefinition 
     | 
| 
      
 247 
     | 
    
         
            +
                        doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, VelcronAppDefinition<object>, {
         
     | 
| 
       248 
248 
     | 
    
         
             
                            "onUpdate:modelValue": {
         
     | 
| 
       249 
     | 
    
         
            -
                                type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 249 
     | 
    
         
            +
                                type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       250 
250 
     | 
    
         
             
                            };
         
     | 
| 
       251 
251 
     | 
    
         
             
                        } & {
         
     | 
| 
       252 
252 
     | 
    
         
             
                            "v-model": {
         
     | 
| 
       253 
     | 
    
         
            -
                                type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 253 
     | 
    
         
            +
                                type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       254 
254 
     | 
    
         
             
                                required: false;
         
     | 
| 
       255 
255 
     | 
    
         
             
                            };
         
     | 
| 
       256 
256 
     | 
    
         
             
                        } & {
         
     | 
| 
       257 
257 
     | 
    
         
             
                            modelValue: {
         
     | 
| 
       258 
     | 
    
         
            -
                                type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 258 
     | 
    
         
            +
                                type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       259 
259 
     | 
    
         
             
                                required: false;
         
     | 
| 
       260 
260 
     | 
    
         
             
                            };
         
     | 
| 
       261 
261 
     | 
    
         
             
                        }>;
         
     | 
| 
       262 
262 
     | 
    
         
             
                    };
         
     | 
| 
       263 
263 
     | 
    
         
             
                }>> & {
         
     | 
| 
       264 
     | 
    
         
            -
                    "onUpdate:modelValue"?: (value: VelcronAppDefinition) => any;
         
     | 
| 
      
 264 
     | 
    
         
            +
                    "onUpdate:modelValue"?: (value: VelcronAppDefinition<object>) => any;
         
     | 
| 
       265 
265 
     | 
    
         
             
                } & import("vue").ShallowUnwrapRef<() => JSX.Element[]> & {} & import("vue").ComponentCustomProperties & {};
         
     | 
| 
       266 
266 
     | 
    
         
             
                __isFragment?: never;
         
     | 
| 
       267 
267 
     | 
    
         
             
                __isTeleport?: never;
         
     | 
| 
         @@ -273,144 +273,144 @@ declare const _default: { 
     | 
|
| 
       273 
273 
     | 
    
         
             
                    type: import("vue").PropType<VelcronDefinitionEditableProperty[]>;
         
     | 
| 
       274 
274 
     | 
    
         
             
                };
         
     | 
| 
       275 
275 
     | 
    
         
             
                "onUpdate:modelValue": {
         
     | 
| 
       276 
     | 
    
         
            -
                    type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 276 
     | 
    
         
            +
                    type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       277 
277 
     | 
    
         
             
                };
         
     | 
| 
       278 
278 
     | 
    
         
             
                "v-model": {
         
     | 
| 
       279 
     | 
    
         
            -
                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 279 
     | 
    
         
            +
                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       280 
280 
     | 
    
         
             
                    required: false;
         
     | 
| 
       281 
281 
     | 
    
         
             
                };
         
     | 
| 
       282 
282 
     | 
    
         
             
                modelValue: {
         
     | 
| 
       283 
     | 
    
         
            -
                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 283 
     | 
    
         
            +
                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       284 
284 
     | 
    
         
             
                    required: false;
         
     | 
| 
       285 
285 
     | 
    
         
             
                };
         
     | 
| 
       286 
286 
     | 
    
         
             
                name: <TName extends string>(n?: TName) => { [key in import("../../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
         
     | 
| 
       287 
     | 
    
         
            -
                    type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 287 
     | 
    
         
            +
                    type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       288 
288 
     | 
    
         
             
                }; } & { [key_1 in import("../../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
         
     | 
| 
       289 
     | 
    
         
            -
                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 289 
     | 
    
         
            +
                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       290 
290 
     | 
    
         
             
                    required: false;
         
     | 
| 
       291 
291 
     | 
    
         
             
                }; } & { [key_2 in import("../../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
         
     | 
| 
       292 
     | 
    
         
            -
                    type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 292 
     | 
    
         
            +
                    type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       293 
293 
     | 
    
         
             
                    required: false;
         
     | 
| 
       294 
294 
     | 
    
         
             
                }; } & {
         
     | 
| 
       295 
     | 
    
         
            -
                    require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, VelcronAppDefinition 
     | 
| 
      
 295 
     | 
    
         
            +
                    require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, VelcronAppDefinition<object>, {
         
     | 
| 
       296 
296 
     | 
    
         
             
                        "onUpdate:modelValue": {
         
     | 
| 
       297 
     | 
    
         
            -
                            type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 297 
     | 
    
         
            +
                            type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       298 
298 
     | 
    
         
             
                        };
         
     | 
| 
       299 
299 
     | 
    
         
             
                    } & {
         
     | 
| 
       300 
300 
     | 
    
         
             
                        "v-model": {
         
     | 
| 
       301 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 301 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       302 
302 
     | 
    
         
             
                            required: false;
         
     | 
| 
       303 
303 
     | 
    
         
             
                        };
         
     | 
| 
       304 
304 
     | 
    
         
             
                    } & {
         
     | 
| 
       305 
305 
     | 
    
         
             
                        modelValue: {
         
     | 
| 
       306 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 306 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       307 
307 
     | 
    
         
             
                            required: false;
         
     | 
| 
       308 
308 
     | 
    
         
             
                        };
         
     | 
| 
       309 
309 
     | 
    
         
             
                    }>;
         
     | 
| 
       310 
     | 
    
         
            -
                    defaultValue(value?: VelcronAppDefinition): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, VelcronAppDefinition 
     | 
| 
      
 310 
     | 
    
         
            +
                    defaultValue(value?: VelcronAppDefinition<object>): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, VelcronAppDefinition<object>, {
         
     | 
| 
       311 
311 
     | 
    
         
             
                        "onUpdate:modelValue": {
         
     | 
| 
       312 
     | 
    
         
            -
                            type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 312 
     | 
    
         
            +
                            type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       313 
313 
     | 
    
         
             
                        };
         
     | 
| 
       314 
314 
     | 
    
         
             
                    } & {
         
     | 
| 
       315 
315 
     | 
    
         
             
                        "v-model": {
         
     | 
| 
       316 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 316 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       317 
317 
     | 
    
         
             
                            required: false;
         
     | 
| 
       318 
318 
     | 
    
         
             
                        };
         
     | 
| 
       319 
319 
     | 
    
         
             
                    } & {
         
     | 
| 
       320 
320 
     | 
    
         
             
                        modelValue: {
         
     | 
| 
       321 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 321 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       322 
322 
     | 
    
         
             
                            required: false;
         
     | 
| 
       323 
323 
     | 
    
         
             
                        };
         
     | 
| 
       324 
324 
     | 
    
         
             
                    }, false>;
         
     | 
| 
       325 
     | 
    
         
            -
                    doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, VelcronAppDefinition 
     | 
| 
      
 325 
     | 
    
         
            +
                    doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, VelcronAppDefinition<object>, {
         
     | 
| 
       326 
326 
     | 
    
         
             
                        "onUpdate:modelValue": {
         
     | 
| 
       327 
     | 
    
         
            -
                            type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 327 
     | 
    
         
            +
                            type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       328 
328 
     | 
    
         
             
                        };
         
     | 
| 
       329 
329 
     | 
    
         
             
                    } & {
         
     | 
| 
       330 
330 
     | 
    
         
             
                        "v-model": {
         
     | 
| 
       331 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 331 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       332 
332 
     | 
    
         
             
                            required: false;
         
     | 
| 
       333 
333 
     | 
    
         
             
                        };
         
     | 
| 
       334 
334 
     | 
    
         
             
                    } & {
         
     | 
| 
       335 
335 
     | 
    
         
             
                        modelValue: {
         
     | 
| 
       336 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 336 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       337 
337 
     | 
    
         
             
                            required: false;
         
     | 
| 
       338 
338 
     | 
    
         
             
                        };
         
     | 
| 
       339 
339 
     | 
    
         
             
                    }>;
         
     | 
| 
       340 
340 
     | 
    
         
             
                };
         
     | 
| 
       341 
341 
     | 
    
         
             
            }>> & {
         
     | 
| 
       342 
     | 
    
         
            -
                "onUpdate:modelValue"?: (value: VelcronAppDefinition) => any;
         
     | 
| 
      
 342 
     | 
    
         
            +
                "onUpdate:modelValue"?: (value: VelcronAppDefinition<object>) => any;
         
     | 
| 
       343 
343 
     | 
    
         
             
            }, () => JSX.Element[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
         
     | 
| 
       344 
344 
     | 
    
         
             
                "update:modelValue": (value: VelcronAppDefinition) => true;
         
     | 
| 
       345 
345 
     | 
    
         
             
            }, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
         
     | 
| 
       346 
346 
     | 
    
         
             
                propsDefinition: Omit<Readonly<{} & {
         
     | 
| 
       347 
347 
     | 
    
         
             
                    name?: {
         
     | 
| 
       348 
348 
     | 
    
         
             
                        [x: `onUpdate:${string}`]: {
         
     | 
| 
       349 
     | 
    
         
            -
                            type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 349 
     | 
    
         
            +
                            type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       350 
350 
     | 
    
         
             
                        };
         
     | 
| 
       351 
351 
     | 
    
         
             
                    } & {
         
     | 
| 
       352 
352 
     | 
    
         
             
                        [x: `v-model:${string}`]: {
         
     | 
| 
       353 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 353 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       354 
354 
     | 
    
         
             
                            required: false;
         
     | 
| 
       355 
355 
     | 
    
         
             
                        };
         
     | 
| 
       356 
356 
     | 
    
         
             
                    } & {
         
     | 
| 
       357 
357 
     | 
    
         
             
                        [x: string]: {
         
     | 
| 
       358 
     | 
    
         
            -
                            type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 358 
     | 
    
         
            +
                            type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       359 
359 
     | 
    
         
             
                            required: false;
         
     | 
| 
       360 
360 
     | 
    
         
             
                        };
         
     | 
| 
       361 
361 
     | 
    
         
             
                    } & {
         
     | 
| 
       362 
     | 
    
         
            -
                        require(): import("../../../DefineVueTypings").DefinePropModelRequire<string, VelcronAppDefinition 
     | 
| 
      
 362 
     | 
    
         
            +
                        require(): import("../../../DefineVueTypings").DefinePropModelRequire<string, VelcronAppDefinition<object>, {
         
     | 
| 
       363 
363 
     | 
    
         
             
                            "onUpdate:modelValue": {
         
     | 
| 
       364 
     | 
    
         
            -
                                type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 364 
     | 
    
         
            +
                                type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       365 
365 
     | 
    
         
             
                            };
         
     | 
| 
       366 
366 
     | 
    
         
             
                        } & {
         
     | 
| 
       367 
367 
     | 
    
         
             
                            "v-model": {
         
     | 
| 
       368 
     | 
    
         
            -
                                type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 368 
     | 
    
         
            +
                                type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       369 
369 
     | 
    
         
             
                                required: false;
         
     | 
| 
       370 
370 
     | 
    
         
             
                            };
         
     | 
| 
       371 
371 
     | 
    
         
             
                        } & {
         
     | 
| 
       372 
372 
     | 
    
         
             
                            modelValue: {
         
     | 
| 
       373 
     | 
    
         
            -
                                type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 373 
     | 
    
         
            +
                                type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       374 
374 
     | 
    
         
             
                                required: false;
         
     | 
| 
       375 
375 
     | 
    
         
             
                            };
         
     | 
| 
       376 
376 
     | 
    
         
             
                        }>;
         
     | 
| 
       377 
     | 
    
         
            -
                        defaultValue(value?: VelcronAppDefinition): import("../../../DefineVueTypings").DefinePropModelDefaultValue<string, VelcronAppDefinition 
     | 
| 
      
 377 
     | 
    
         
            +
                        defaultValue(value?: VelcronAppDefinition<object>): import("../../../DefineVueTypings").DefinePropModelDefaultValue<string, VelcronAppDefinition<object>, {
         
     | 
| 
       378 
378 
     | 
    
         
             
                            "onUpdate:modelValue": {
         
     | 
| 
       379 
     | 
    
         
            -
                                type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 379 
     | 
    
         
            +
                                type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       380 
380 
     | 
    
         
             
                            };
         
     | 
| 
       381 
381 
     | 
    
         
             
                        } & {
         
     | 
| 
       382 
382 
     | 
    
         
             
                            "v-model": {
         
     | 
| 
       383 
     | 
    
         
            -
                                type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 383 
     | 
    
         
            +
                                type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       384 
384 
     | 
    
         
             
                                required: false;
         
     | 
| 
       385 
385 
     | 
    
         
             
                            };
         
     | 
| 
       386 
386 
     | 
    
         
             
                        } & {
         
     | 
| 
       387 
387 
     | 
    
         
             
                            modelValue: {
         
     | 
| 
       388 
     | 
    
         
            -
                                type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 388 
     | 
    
         
            +
                                type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       389 
389 
     | 
    
         
             
                                required: false;
         
     | 
| 
       390 
390 
     | 
    
         
             
                            };
         
     | 
| 
       391 
391 
     | 
    
         
             
                        }, false>;
         
     | 
| 
       392 
     | 
    
         
            -
                        doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<string, VelcronAppDefinition 
     | 
| 
      
 392 
     | 
    
         
            +
                        doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<string, VelcronAppDefinition<object>, {
         
     | 
| 
       393 
393 
     | 
    
         
             
                            "onUpdate:modelValue": {
         
     | 
| 
       394 
     | 
    
         
            -
                                type: import("vue").PropType<(value: VelcronAppDefinition) => any>;
         
     | 
| 
      
 394 
     | 
    
         
            +
                                type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
         
     | 
| 
       395 
395 
     | 
    
         
             
                            };
         
     | 
| 
       396 
396 
     | 
    
         
             
                        } & {
         
     | 
| 
       397 
397 
     | 
    
         
             
                            "v-model": {
         
     | 
| 
       398 
     | 
    
         
            -
                                type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 398 
     | 
    
         
            +
                                type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       399 
399 
     | 
    
         
             
                                required: false;
         
     | 
| 
       400 
400 
     | 
    
         
             
                            };
         
     | 
| 
       401 
401 
     | 
    
         
             
                        } & {
         
     | 
| 
       402 
402 
     | 
    
         
             
                            modelValue: {
         
     | 
| 
       403 
     | 
    
         
            -
                                type: import("vue").PropType<VelcronAppDefinition 
     | 
| 
      
 403 
     | 
    
         
            +
                                type: import("vue").PropType<VelcronAppDefinition<object>>;
         
     | 
| 
       404 
404 
     | 
    
         
             
                                required: false;
         
     | 
| 
       405 
405 
     | 
    
         
             
                            };
         
     | 
| 
       406 
406 
     | 
    
         
             
                        }>;
         
     | 
| 
       407 
407 
     | 
    
         
             
                    };
         
     | 
| 
       408 
408 
     | 
    
         
             
                    properties?: VelcronDefinitionEditableProperty[];
         
     | 
| 
       409 
     | 
    
         
            -
                    "onUpdate:modelValue"?: (value: VelcronAppDefinition) => any;
         
     | 
| 
       410 
     | 
    
         
            -
                    "v-model"?: VelcronAppDefinition 
     | 
| 
       411 
     | 
    
         
            -
                    modelValue?: VelcronAppDefinition 
     | 
| 
      
 409 
     | 
    
         
            +
                    "onUpdate:modelValue"?: (value: VelcronAppDefinition<object>) => any;
         
     | 
| 
      
 410 
     | 
    
         
            +
                    "v-model"?: VelcronAppDefinition<object>;
         
     | 
| 
      
 411 
     | 
    
         
            +
                    modelValue?: VelcronAppDefinition<object>;
         
     | 
| 
       412 
412 
     | 
    
         
             
                }>, "onUpdate:modelValue"> & {
         
     | 
| 
       413 
     | 
    
         
            -
                    "onUpdate:modelValue"?: (value: VelcronAppDefinition) => any;
         
     | 
| 
      
 413 
     | 
    
         
            +
                    "onUpdate:modelValue"?: (value: VelcronAppDefinition<object>) => any;
         
     | 
| 
       414 
414 
     | 
    
         
             
                };
         
     | 
| 
       415 
415 
     | 
    
         
             
            };
         
     | 
| 
       416 
416 
     | 
    
         
             
            export default _default;
         
     | 
| 
         @@ -1,5 +1,5 @@ 
     | 
|
| 
       1 
     | 
    
         
            -
            import { VelcronComponentDescriptor } from "../../editor/models/VelcronDescriptors";
         
     | 
| 
       2 
     | 
    
         
            -
            import { VelcronEvent, VelcronOnChangedEvent, VelcronOnClosedEvent, VelcronOnCloseRequestedEvent, VelcronOnLoadEvent, VelcronOnPressEvent } from "./VelcronEvents";
         
     | 
| 
      
 1 
     | 
    
         
            +
            import { VelcronComponentDescriptor, VelcronDefinitionEditableProperty } from "../../editor/models/VelcronDescriptors";
         
     | 
| 
      
 2 
     | 
    
         
            +
            import { VelcronEvent, VelcronOnChangedEvent, VelcronOnClosedEvent, VelcronOnCloseRequestedEvent, VelcronOnEditModeEvent, VelcronOnLoadEvent, VelcronOnPressEvent } from "./VelcronEvents";
         
     | 
| 
       3 
3 
     | 
    
         
             
            import { VelcroncomponentArrayType, VelcronPrimitiveType } from "./VelcronTypes";
         
     | 
| 
       4 
4 
     | 
    
         
             
            import { AssignOperators, VelcronHorizontalAlignments, VelcronIconTypes, VelcronActionTypes, VelcronVerticalAlignments } from "./Enums";
         
     | 
| 
       5 
5 
     | 
    
         
             
            import { useVelcronThemingStore } from "..";
         
     | 
| 
         @@ -28,19 +28,15 @@ export interface ColorSchemaReference { 
     | 
|
| 
       28 
28 
     | 
    
         
             
                name: string;
         
     | 
| 
       29 
29 
     | 
    
         
             
                schema: string;
         
     | 
| 
       30 
30 
     | 
    
         
             
            }
         
     | 
| 
       31 
     | 
    
         
            -
            export  
     | 
| 
       32 
     | 
    
         
            -
                colorSchemas?: {
         
     | 
| 
       33 
     | 
    
         
            -
                    [key: string]: ColorSchemaReference;
         
     | 
| 
       34 
     | 
    
         
            -
                };
         
     | 
| 
       35 
     | 
    
         
            -
            }
         
     | 
| 
      
 31 
     | 
    
         
            +
            export type DynamicState = object;
         
     | 
| 
       36 
32 
     | 
    
         
             
            export interface OnItemRenderedHookResult {
         
     | 
| 
       37 
33 
     | 
    
         
             
                cssClass: string;
         
     | 
| 
       38 
34 
     | 
    
         
             
                containerRenderer?: VelcronContainerRenderer;
         
     | 
| 
       39 
35 
     | 
    
         
             
            }
         
     | 
| 
       40 
36 
     | 
    
         
             
            export interface VelcronRenderContext {
         
     | 
| 
       41 
37 
     | 
    
         
             
                id?: string;
         
     | 
| 
       42 
     | 
    
         
            -
                rootContext:  
     | 
| 
       43 
     | 
    
         
            -
                currentContext:  
     | 
| 
      
 38 
     | 
    
         
            +
                rootContext: DynamicState;
         
     | 
| 
      
 39 
     | 
    
         
            +
                currentContext: DynamicState;
         
     | 
| 
       44 
40 
     | 
    
         
             
                theming?: ReturnType<typeof useVelcronThemingStore>;
         
     | 
| 
       45 
41 
     | 
    
         
             
                colors?: ReturnType<typeof useVelcronColorSchemaStore>;
         
     | 
| 
       46 
42 
     | 
    
         
             
                actions?: {
         
     | 
| 
         @@ -56,6 +52,7 @@ export interface VelcronRenderContext { 
     | 
|
| 
       56 
52 
     | 
    
         
             
                parent?: VelcronRenderContext;
         
     | 
| 
       57 
53 
     | 
    
         
             
                hooks?: VelcronRenderContextHooks;
         
     | 
| 
       58 
54 
     | 
    
         
             
                eventHandlers?: VelcronRenderContextEventHandlers;
         
     | 
| 
      
 55 
     | 
    
         
            +
                editMode?: boolean;
         
     | 
| 
       59 
56 
     | 
    
         
             
            }
         
     | 
| 
       60 
57 
     | 
    
         
             
            export interface VelcronRenderContextEventHandlers {
         
     | 
| 
       61 
58 
     | 
    
         
             
                receiving?: {
         
     | 
| 
         @@ -116,6 +113,11 @@ export interface VelcronDefinition extends VelcronDefinitionBase { 
     | 
|
| 
       116 
113 
     | 
    
         
             
                if?: string;
         
     | 
| 
       117 
114 
     | 
    
         
             
                events?: VelcronEvent;
         
     | 
| 
       118 
115 
     | 
    
         
             
            }
         
     | 
| 
      
 116 
     | 
    
         
            +
            export type VelcronBindableProp<TPropType = string> = TPropType | string;
         
     | 
| 
      
 117 
     | 
    
         
            +
            export type VelcronStringBindableProp = string;
         
     | 
| 
      
 118 
     | 
    
         
            +
            export interface VelcronDefinitionWithEditMode extends VelcronDefinition {
         
     | 
| 
      
 119 
     | 
    
         
            +
                edit?: VelcronBindableProp<boolean>;
         
     | 
| 
      
 120 
     | 
    
         
            +
            }
         
     | 
| 
       119 
121 
     | 
    
         
             
            export interface VelcronColorStyling {
         
     | 
| 
       120 
122 
     | 
    
         
             
                colorSchemaType?: string;
         
     | 
| 
       121 
123 
     | 
    
         
             
                color?: string;
         
     | 
| 
         @@ -150,17 +152,17 @@ export interface VelcronIcon { 
     | 
|
| 
       150 
152 
     | 
    
         
             
                type: VelcronIconTypes;
         
     | 
| 
       151 
153 
     | 
    
         
             
                name: string;
         
     | 
| 
       152 
154 
     | 
    
         
             
            }
         
     | 
| 
       153 
     | 
    
         
            -
            export interface VelcronAppDefinition extends VelcronDefinitionBase {
         
     | 
| 
      
 155 
     | 
    
         
            +
            export interface VelcronAppDefinition<TState extends DynamicState = DynamicState> extends VelcronDefinitionBase {
         
     | 
| 
       154 
156 
     | 
    
         
             
                type: "Velcron";
         
     | 
| 
       155 
157 
     | 
    
         
             
                version: string;
         
     | 
| 
       156 
158 
     | 
    
         
             
                name: string;
         
     | 
| 
       157 
159 
     | 
    
         
             
                body?: Array<VelcronDefinition>;
         
     | 
| 
       158 
     | 
    
         
            -
                events?: VelcronOnLoadEvent &  
     | 
| 
      
 160 
     | 
    
         
            +
                events?: VelcronOnLoadEvent & VelcronOnEditModeEvent;
         
     | 
| 
       159 
161 
     | 
    
         
             
                actions?: {
         
     | 
| 
       160 
162 
     | 
    
         
             
                    [name: string]: [];
         
     | 
| 
       161 
163 
     | 
    
         
             
                };
         
     | 
| 
       162 
164 
     | 
    
         
             
                components?: Array<VelcronCustomComponentDefinition>;
         
     | 
| 
       163 
     | 
    
         
            -
                state?:  
     | 
| 
      
 165 
     | 
    
         
            +
                state?: TState;
         
     | 
| 
       164 
166 
     | 
    
         
             
                computed?: {
         
     | 
| 
       165 
167 
     | 
    
         
             
                    [name: string]: [];
         
     | 
| 
       166 
168 
     | 
    
         
             
                };
         
     | 
| 
         @@ -190,14 +192,16 @@ export interface VelcronCardDefinition extends VelcronDefinition { 
     | 
|
| 
       190 
192 
     | 
    
         
             
                footer?: Array<VelcronDefinition>;
         
     | 
| 
       191 
193 
     | 
    
         
             
                events?: VelcronOnPressEvent;
         
     | 
| 
       192 
194 
     | 
    
         
             
            }
         
     | 
| 
       193 
     | 
    
         
            -
            export interface VelcronTextDefinition extends  
     | 
| 
      
 195 
     | 
    
         
            +
            export interface VelcronTextDefinition extends VelcronDefinitionEditableProperty {
         
     | 
| 
       194 
196 
     | 
    
         
             
                type: "Text";
         
     | 
| 
       195 
197 
     | 
    
         
             
                text: string;
         
     | 
| 
      
 198 
     | 
    
         
            +
                bind: string;
         
     | 
| 
      
 199 
     | 
    
         
            +
                editLabel?: VelcronBindableProp;
         
     | 
| 
       196 
200 
     | 
    
         
             
                color?: string;
         
     | 
| 
       197 
201 
     | 
    
         
             
                lineClamp?: number;
         
     | 
| 
       198 
202 
     | 
    
         
             
                noWrap?: boolean;
         
     | 
| 
       199 
203 
     | 
    
         
             
                typography?: string;
         
     | 
| 
       200 
     | 
    
         
            -
                events?: VelcronOnPressEvent;
         
     | 
| 
      
 204 
     | 
    
         
            +
                events?: VelcronOnPressEvent & VelcronOnChangedEvent;
         
     | 
| 
       201 
205 
     | 
    
         
             
            }
         
     | 
| 
       202 
206 
     | 
    
         
             
            export declare enum VelcronImageRatios {
         
     | 
| 
       203 
207 
     | 
    
         
             
                square = 1,
         
     | 
| 
         @@ -207,6 +211,7 @@ export interface VelcronImageDefinition extends VelcronDefinition { 
     | 
|
| 
       207 
211 
     | 
    
         
             
                type: "Image";
         
     | 
| 
       208 
212 
     | 
    
         
             
                source: string;
         
     | 
| 
       209 
213 
     | 
    
         
             
                ratio: VelcronImageRatios;
         
     | 
| 
      
 214 
     | 
    
         
            +
                cover?: VelcronBindableProp<boolean>;
         
     | 
| 
       210 
215 
     | 
    
         
             
                borderRadius?: VelcronDimensions;
         
     | 
| 
       211 
216 
     | 
    
         
             
                events?: VelcronOnPressEvent;
         
     | 
| 
       212 
217 
     | 
    
         
             
            }
         
     | 
| 
         @@ -245,12 +250,10 @@ export interface VelcronIconDefinition extends VelcronDefinition { 
     | 
|
| 
       245 
250 
     | 
    
         
             
                size?: number;
         
     | 
| 
       246 
251 
     | 
    
         
             
                events?: VelcronOnPressEvent;
         
     | 
| 
       247 
252 
     | 
    
         
             
            }
         
     | 
| 
       248 
     | 
    
         
            -
            export interface VelcronMarkdownDefinition extends  
     | 
| 
      
 253 
     | 
    
         
            +
            export interface VelcronMarkdownDefinition extends VelcronDefinitionWithEditMode {
         
     | 
| 
       249 
254 
     | 
    
         
             
                type: "Markdown";
         
     | 
| 
       250 
255 
     | 
    
         
             
                text: string;
         
     | 
| 
       251 
     | 
    
         
            -
                initialValue: string;
         
     | 
| 
       252 
256 
     | 
    
         
             
                bind: string;
         
     | 
| 
       253 
     | 
    
         
            -
                edit?: boolean | string;
         
     | 
| 
       254 
257 
     | 
    
         
             
                events: VelcronOnChangedEvent;
         
     | 
| 
       255 
258 
     | 
    
         
             
            }
         
     | 
| 
       256 
259 
     | 
    
         
             
            export interface VelcronDimensions {
         
     |