@omnia/fx 8.0.20-vnext → 8.0.22-vnext

package/internal-do-not-import-from-here/ux/DefineVueTypings.d.ts

@@ -0,0 +1,108 @@
+import { Prop, PropType, VNodeChild } from "vue";
+import { Func } from "../models/Func";
+export type Slot<T extends any[] = any[]> = (...args: T) => VNodeChild;
+export type VModelKeyNameInJsxElement<N extends string> = N extends "" ? "v-model" : `v-model:${N}`;
+export type VModelKeyNameInProps<N extends string> = N extends "" ? "modelValue" : N;
+type BuildVModelName<TName extends string, TPropType, Required extends boolean = false> = {
+    [key in VModelKeyNameInJsxElement<TName>]: {
+        type: PropType<TPropType>;
+        required: Required;
+    };
+} & {
+    [key in VModelKeyNameInProps<TName>]: {
+        type: PropType<TPropType>;
+        required: Required;
+    };
+};
+export type KebabKeys<T> = {
+    [K in keyof T as K extends string ? Kebab<K> : never]: T[K];
+};
+export type Kebab<T extends string, A extends string = ""> = T extends `${infer F}${infer R}` ? Kebab<R, `${A}${F extends Lowercase<F> ? "" : "-"}${Lowercase<F>}`> : A;
+export type DefinePropRequire<TName extends string, TPropType, E> = E & {
+    [K in TName]: {
+        type: PropType<TPropType>;
+        required: true;
+    };
+} & {
+    defaultValue(value?: TPropType): Omit<DefinePropDefaultValue<TName, TPropType, E, true>, "require">;
+    doc$(description?: string): Omit<DefinePropRequire<TName, TPropType, E>, "doc$">;
+};
+export type DefinePropDefaultValue<TName extends string, TPropType, E, Required extends boolean = false> = E & {
+    [K in TName]: {
+        type: PropType<TPropType>;
+        required: Required;
+    };
+} & {
+    require(): Omit<DefinePropRequire<TName, TPropType, E>, "defaultValue">;
+    doc$(description?: string): Omit<DefinePropDefaultValue<TName, TPropType, E>, "doc$">;
+};
+export type DefinePropDoc<TName extends string, TPropType, E> = E & {
+    [K in TName]: {
+        type: PropType<TPropType>;
+    };
+} & {
+    require(): Omit<DefinePropRequire<TName, TPropType, E>, "defaultValue">;
+    defaultValue(value?: TPropType): Omit<DefinePropDefaultValue<TName, TPropType, E>, "require">;
+};
+export type DefinePropModelRequire<N extends string, TPropType, E> = E & BuildVModelName<N, TPropType, true> & {
+    defaultValue(value?: TPropType): Omit<DefinePropModelDefaultValue<N, TPropType, E, true>, "require">;
+    doc$(description?: string): Omit<DefinePropModelRequire<N, TPropType, E>, "doc$">;
+};
+export type DefinePropModelDefaultValue<N extends string, TPropType, E, Required extends boolean = false> = E & BuildVModelName<N, TPropType, Required> & {
+    require(): Omit<DefinePropModelRequire<N, TPropType, E>, "defaultValue">;
+    doc$(description?: string): Omit<DefinePropModelDefaultValue<N, TPropType, E>, "doc$">;
+};
+export type DefinePropModelDoc<TName extends string, TPropType, E> = E & BuildVModelName<TName, TPropType> & {
+    require(): Omit<DefinePropModelRequire<TName, TPropType, E>, "defaultValue">;
+    defaultValue(value?: TPropType): Omit<DefinePropModelDefaultValue<TName, TPropType, E>, "require">;
+};
+export type DefinePropModelSlots = {
+    slots<Slots extends Record<string, Slot>>(): {
+        "v-slots": Prop<{
+            default?: Func<[VNodeChild]>;
+        } & Slots>;
+        doc$(doc?: {
+            [K in keyof Slots]: string;
+        }): {
+            "v-slots": Prop<{
+                default?: Func<[VNodeChild]>;
+            } & Slots>;
+        };
+    };
+    vModel<TPropType>(): BuildVModelName<"", TPropType> & {
+        require(): DefinePropModelRequire<"", TPropType, {}>;
+        defaultValue(value?: TPropType): DefinePropModelDefaultValue<"", TPropType, {}>;
+        doc$(description?: string): DefinePropModelDoc<"", TPropType, {}>;
+    } & {
+        name<TName extends string>(n?: TName): BuildVModelName<TName, TPropType> & {
+            require(): DefinePropModelRequire<TName, TPropType, BuildVModelName<"", TPropType>>;
+            defaultValue(value?: TPropType): DefinePropModelDefaultValue<TName, TPropType, BuildVModelName<"", TPropType>>;
+            doc$(description?: string): DefinePropModelDoc<TName, TPropType, BuildVModelName<"", TPropType>>;
+        };
+    };
+    prop<TPropType>(): {
+        name<TName extends string>(n: TName): KebabKeys<{
+            [K in TName]: {
+                type: PropType<TPropType>;
+            };
+        }> & {
+            [K in TName]: {
+                type: PropType<TPropType>;
+            };
+        } & {
+            require(): DefinePropRequire<TName, TPropType, {}>;
+            defaultValue(value?: TPropType): DefinePropDefaultValue<TName, TPropType, {}>;
+            doc$(description?: string): DefinePropDoc<TName, TPropType, {}>;
+        };
+    };
+    emit<TEmitType>(): {
+        name<TName extends string>(n: TName): {
+            [K in TName]: TEmitType;
+        } & {
+            doc$(description?: string): {
+                [K in TName]: TEmitType;
+            };
+        };
+    };
+};
+export {};

package/internal-do-not-import-from-here/ux/InternalDefineWebComponent.d.ts

@@ -1,6 +1,8 @@
 import { ComputedOptions, MethodOptions, ComponentOptionsMixin, EmitsOptions, ComponentInjectOptions, ComponentPropsOptions, DefineComponent, ComponentObjectPropsOptions, Prop, VNodeChild, PropType, ObjectEmitsOptions, CreateComponentPublicInstance, ExtractPropTypes, ExtractDefaultPropTypes, ComponentOptionsBase, RenderFunction, VNode } from "vue";
 import { LooseRequired, UnionToIntersection } from "@vue/shared";
-import { Func, ThemeableComponentProps, WebComponentBundleManifest } from "@omnia/fx-models";
+import { ThemeableComponentProps, WebComponentBundleManifest } from "@omnia/fx-models";
+import { useColorSchemaSetup } from "./use";
+import { Slot } from "./DefineVueTypings";
 export declare function definePropFunctionType<T>(): PropType<T>;
 export declare function definePropObjectType<T>(): PropType<T>;
 type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
@@ -26,7 +28,7 @@ type InferPropType<T> = [T] extends [null] ? any : [T] extends [
     }
 ] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? IfAny<V, V, D> : V : T;
 type RemoveDefinePropApi<T> = T extends string[] ? T : {
-    [K in keyof T as K extends "require" | "defaultValue" ? never : K]: T[K];
+    [K in keyof T as K extends "require" | "defaultValue" | "prop" | "vModel" | "slots" | "doc$" ? never : K]: T[K];
 };
 type ExcludeJsxPropKeys<T> = T extends string[] ? T : {
     [K in keyof T as K extends `v-model${infer _}` | "v-slots" ? never : K]: T[K];
@@ -53,18 +55,11 @@ type EmitsToProps<T extends EmitsOptions> = T extends string[] ? {
 type TsxComponentV3<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string> = DefineComponent<PropsOrPropOptions, RawBindings, D, C, M, Mixin, Extends, E, EE> & {
     propsDefinition: Readonly<PropsOrPropOptions extends ComponentPropsOptions ? CustomExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions> & ({} extends E ? {} : EmitsToProps<E>);
 };
-type Slot<T extends any[] = any[]> = (...args: T) => VNodeChild;
 export declare function defineSlotsAndProps<Slots extends Record<string, Slot>>(): <Props>(props: ComponentObjectPropsOptions<Props>) => ComponentObjectPropsOptions<Props> & {
     "v-slots"?: Prop<{
         default?: () => VNodeChild;
     } & Slots>;
 };
-export type VModelKeyNameInJsxElement<N extends string> = N extends "" ? "v-model" : `v-model:${N}`;
-export type VModelKeyNameInProps<N extends string> = N extends "" ? "modelValue" : N;
-type KebabKeys<T> = {
-    [K in keyof T as K extends string ? Kebab<K> : never]: T[K];
-};
-type Kebab<T extends string, A extends string = ""> = T extends `${infer F}${infer R}` ? Kebab<R, `${A}${F extends Lowercase<F> ? "" : "-"}${Lowercase<F>}`> : A;
 type ComponentOptionsWithObjectPropsCustom<PropsOptions = ComponentObjectPropsOptions, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = EmitsOptions, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string, Props = Readonly<ExtractPropTypes<PropsOptions>> & EmitsToProps<E>, Defaults = ExtractDefaultPropTypes<PropsOptions>> = ComponentOptionsBaseExtends<RemoveDefinePropApi<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II> & {
     props: PropsOptions & ThisType<void>;
 } & ThisType<CreateComponentPublicInstance<Props, RawBindings, D, C, M, Mixin, Extends, E, Props, Defaults, false, I>>;
@@ -96,86 +91,98 @@ type SetupContext<Props, E = EmitsOptions> = E extends any ? {
     attrs: Data;
     slots: Slots;
     models?: Required<ExtractPropModels<Props>>;
+    colors: ReturnType<typeof useColorSchemaSetup>;
     emit: EmitFn<E>;
     expose: (exposed?: Record<string, any>) => void;
 } : never;
 interface ComponentOptionsBaseExtends<Props, RawBindings, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, E extends EmitsOptions, EE extends string = string, Defaults = {}, I extends ComponentInjectOptions = {}, II extends string = string> extends ComponentOptionsBase<ExcludeJsxPropKeys<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, I, II> {
     setup?: (this: void, props: Readonly<LooseRequired<ExcludeJsxPropKeys<Props> & UnionToIntersection<ExtractOptionProp<Mixin>> & UnionToIntersection<ExtractOptionProp<Extends>>>>, ctx: SetupContext<Props, E>) => Promise<RawBindings> | RawBindings | RenderFunction | void;
 }
-type DefinePropRequire<TName extends string, TPropType> = {
-    [K in TName]: {
-        type: PropType<TPropType>;
-        required: true;
-    };
-} & {
-    defaultValue(value?: TPropType): Omit<DefineProplDefaultValue<TName, TPropType, true>, "require">;
-};
-type DefineProplDefaultValue<TName extends string, TPropType, Required extends boolean = false> = KebabKeys<{
-    [K in TName]: {
-        type: PropType<TPropType>;
-        required: Required;
-    };
-}> & {
-    [K in TName]: {
-        type: PropType<TPropType>;
-        required: Required;
-    };
-} & {
-    require(): Omit<DefinePropRequire<TName, TPropType>, "defaultValue">;
-};
-type DefineProp<TName extends string, TPropType> = KebabKeys<{
-    [K in TName]: {
-        type: PropType<TPropType>;
-    };
-}> & {
-    [K in TName]: {
-        type: PropType<TPropType>;
-    };
-} & {
-    require(): DefinePropRequire<TName, TPropType>;
-    defaultValue?(value?: TPropType): DefineProplDefaultValue<TName, TPropType>;
-};
-type DefinePropModelRequire<N extends string, TPropType> = {
-    [key in VModelKeyNameInJsxElement<N>]: {
-        type: PropType<TPropType>;
-        required: true;
-    };
-} & {
-    [key in VModelKeyNameInProps<N>]: {
-        type: PropType<TPropType>;
-        required: true;
-    };
-} & {
-    defaultValue(value?: TPropType): Omit<DefinePropModelDefaultValue<N, TPropType, true>, "require">;
-};
-type DefinePropModelDefaultValue<N extends string, TPropType, Required extends boolean = false> = {
-    [key in VModelKeyNameInJsxElement<N>]: {
-        type: PropType<TPropType>;
-        required: Required;
+export declare function createPropType<T>(): PropType<T>;
+export declare function defineVue(): {
+    slots<Slots_1 extends Record<string, Slot<any[]>>>(): {
+        "v-slots": Prop<{
+            default?: import("@omnia/fx-models").Func<[VNodeChild]>;
+        } & Slots_1>;
+        doc$(doc?: { [K in keyof Slots_1]: string; }): {
+            "v-slots": Prop<{
+                default?: import("@omnia/fx-models").Func<[VNodeChild]>;
+            } & Slots_1>;
+        };
     };
-} & {
-    [key in VModelKeyNameInProps<N>]: {
-        type: PropType<TPropType>;
-        required: Required;
+    vModel<TPropType>(): {
+        "v-model": {
+            type: PropType<TPropType>;
+            required: false;
+        };
+    } & {
+        modelValue: {
+            type: PropType<TPropType>;
+            required: false;
+        };
+    } & {
+        require(): import("./DefineVueTypings").DefinePropModelRequire<"", TPropType, {}>;
+        defaultValue(value?: TPropType): import("./DefineVueTypings").DefinePropModelDefaultValue<"", TPropType, {}, false>;
+        doc$(description?: string): import("./DefineVueTypings").DefinePropModelDoc<"", TPropType, {}>;
+    } & {
+        name<TName extends string>(n?: TName): { [key in import("./DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
+            type: PropType<TPropType>;
+            required: false;
+        }; } & { [key_1 in import("./DefineVueTypings").VModelKeyNameInProps<TName>]: {
+            type: PropType<TPropType>;
+            required: false;
+        }; } & {
+            require(): import("./DefineVueTypings").DefinePropModelRequire<TName, TPropType, {
+                "v-model": {
+                    type: PropType<TPropType>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: PropType<TPropType>;
+                    required: false;
+                };
+            }>;
+            defaultValue(value?: TPropType): import("./DefineVueTypings").DefinePropModelDefaultValue<TName, TPropType, {
+                "v-model": {
+                    type: PropType<TPropType>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: PropType<TPropType>;
+                    required: false;
+                };
+            }, false>;
+            doc$(description?: string): import("./DefineVueTypings").DefinePropModelDoc<TName, TPropType, {
+                "v-model": {
+                    type: PropType<TPropType>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: PropType<TPropType>;
+                    required: false;
+                };
+            }>;
+        };
     };
-} & {
-    require(): Omit<DefinePropModelRequire<N, TPropType>, "defaultValue">;
-};
-type DefinePropModel<N extends string, TPropType> = {
-    [key in VModelKeyNameInJsxElement<N>]: {
-        type: PropType<TPropType>;
+    prop<TPropType_1>(): {
+        name<TName_1 extends string>(n: TName_1): import("./DefineVueTypings").KebabKeys<{ [K_1 in TName_1]: {
+            type: PropType<TPropType_1>;
+        }; }> & { [K_2 in TName_1]: {
+            type: PropType<TPropType_1>;
+        }; } & {
+            require(): import("./DefineVueTypings").DefinePropRequire<TName_1, TPropType_1, {}>;
+            defaultValue(value?: TPropType_1): import("./DefineVueTypings").DefinePropDefaultValue<TName_1, TPropType_1, {}, false>;
+            doc$(description?: string): import("./DefineVueTypings").DefinePropDoc<TName_1, TPropType_1, {}>;
+        };
     };
-} & {
-    [key in VModelKeyNameInProps<N>]: {
-        type: PropType<TPropType>;
+    emit<TEmitType>(): {
+        name<TName_2 extends string>(n: TName_2): { [K_3 in TName_2]: TEmitType; } & {
+            doc$(description?: string): { [K_4 in TName_2]: TEmitType; };
+        };
     };
-} & {
-    require(): DefinePropModelRequire<N, TPropType>;
-    defaultValue?(value?: TPropType): DefinePropModelDefaultValue<N, TPropType>;
-};
-export declare function createPropType<T>(): PropType<T>;
-export declare function defineVue<TPropType>(): {
-    prop<TName extends string>(name: TName): DefineProp<TName, TPropType>;
     props: () => {
         theming: ThemeableComponentProps;
         class: {
@@ -185,12 +192,6 @@ export declare function defineVue<TPropType>(): {
             };
         };
     };
-    vModel<N extends string = "">(name?: N): DefinePropModel<N, TPropType>;
-    slots: <Slots_1 extends Record<string, Slot<any[]>>>() => {
-        "v-slots": Prop<{
-            default?: Func<[VNodeChild]>;
-        } & Slots_1>;
-    };
 };
 export declare function defineVueComponent<Props = {}, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithoutProps<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>): TsxComponentV3<Props, RawBindings, D, C, M, Mixin, Extends, E, EE>;
 export declare function defineVueComponent<Props extends Object, RawBindings = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, I extends ComponentInjectOptions = {}, II extends string = string>(options: ComponentOptionsWithObjectPropsCustom<ComponentObjectPropsOptions<Props>, RawBindings, D, C, M, Mixin, Extends, E, EE, I, II>): TsxComponentV3<RemoveDefinePropApi<ComponentObjectPropsOptions<Props>>, RawBindings, D, C, M, Mixin, Extends, E, EE>;

package/internal-do-not-import-from-here/ux/VueTags.d.ts

@@ -104,7 +104,6 @@ export declare const VCalendarCategory = "v-calendar-category";
 export declare const VThemeProviderTag = "v-theme-provider";
 export declare const Draggable = "draggable";
 export declare const Vue2Editor = "vue-editor";
-export declare const MonacoEditor = "monaco-editor";
 export declare const VueChartJSLineChart = "vue-chartjs-line-chart";
 export declare const VueChartJSBarChart = "vue-chartjs-bar-chart";
 export declare const VueChartJSPieChart = "vue-chartjs-pie-chart";

package/internal-do-not-import-from-here/ux/app/management/tabs/instance/Item.d.ts

@@ -79,8 +79,8 @@ declare const _default: {
     openAppWizard: import("vue").Prop<(initAppInsance: AppInstance, initAppTemplate: AppTemplate) => void, (initAppInsance: AppInstance, initAppTemplate: AppTemplate) => void>;
 }>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Readonly<{} & {
-        tabId?: string;
         item?: AppInstance;
+        tabId?: string;
         editApp?: (item: AppInstance) => void;
         deleteApp?: (item: AppInstance) => void;
         openFeatures?: (appInstance: AppInstance) => void;

package/internal-do-not-import-from-here/ux/app/management/tabs/templates/Template.d.ts

@@ -64,9 +64,9 @@ declare const _default: {
 }>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Readonly<{} & {
         delete?: () => void;
-        edit?: (template: AppTemplate) => void;
         cols?: number;
         item?: AppTemplate;
+        edit?: (template: AppTemplate) => void;
     }>;
 };
 export default _default;

package/internal-do-not-import-from-here/ux/compositiontests/OptionsBlockCurrent.d.ts

@@ -6,9 +6,52 @@ declare const _default: {
         $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{
             "v-model": {
                 type: import("vue").PropType<string>;
+                required: false;
             };
             modelValue: {
                 type: import("vue").PropType<string>;
+                required: false;
+            };
+            name: <TName extends string>(n?: TName) => { [key in import("../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
+                type: import("vue").PropType<string>;
+                required: false;
+            }; } & { [key_1 in import("../DefineVueTypings").VModelKeyNameInProps<TName>]: {
+                type: import("vue").PropType<string>;
+                required: false;
+            }; } & {
+                require(): import("../DefineVueTypings").DefinePropModelRequire<TName, string, {
+                    "v-model": {
+                        type: import("vue").PropType<string>;
+                        required: false;
+                    };
+                } & {
+                    modelValue: {
+                        type: import("vue").PropType<string>;
+                        required: false;
+                    };
+                }>;
+                defaultValue(value?: string): import("../DefineVueTypings").DefinePropModelDefaultValue<TName, string, {
+                    "v-model": {
+                        type: import("vue").PropType<string>;
+                        required: false;
+                    };
+                } & {
+                    modelValue: {
+                        type: import("vue").PropType<string>;
+                        required: false;
+                    };
+                }, false>;
+                doc$(description?: string): import("../DefineVueTypings").DefinePropModelDoc<TName, string, {
+                    "v-model": {
+                        type: import("vue").PropType<string>;
+                        required: false;
+                    };
+                } & {
+                    modelValue: {
+                        type: import("vue").PropType<string>;
+                        required: false;
+                    };
+                }>;
             };
         }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
         $attrs: {
@@ -27,9 +70,52 @@ declare const _default: {
         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
             "v-model": {
                 type: import("vue").PropType<string>;
+                required: false;
             };
             modelValue: {
                 type: import("vue").PropType<string>;
+                required: false;
+            };
+            name: <TName extends string>(n?: TName) => { [key in import("../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
+                type: import("vue").PropType<string>;
+                required: false;
+            }; } & { [key_1 in import("../DefineVueTypings").VModelKeyNameInProps<TName>]: {
+                type: import("vue").PropType<string>;
+                required: false;
+            }; } & {
+                require(): import("../DefineVueTypings").DefinePropModelRequire<TName, string, {
+                    "v-model": {
+                        type: import("vue").PropType<string>;
+                        required: false;
+                    };
+                } & {
+                    modelValue: {
+                        type: import("vue").PropType<string>;
+                        required: false;
+                    };
+                }>;
+                defaultValue(value?: string): import("../DefineVueTypings").DefinePropModelDefaultValue<TName, string, {
+                    "v-model": {
+                        type: import("vue").PropType<string>;
+                        required: false;
+                    };
+                } & {
+                    modelValue: {
+                        type: import("vue").PropType<string>;
+                        required: false;
+                    };
+                }, false>;
+                doc$(description?: string): import("../DefineVueTypings").DefinePropModelDoc<TName, string, {
+                    "v-model": {
+                        type: import("vue").PropType<string>;
+                        required: false;
+                    };
+                } & {
+                    modelValue: {
+                        type: import("vue").PropType<string>;
+                        required: false;
+                    };
+                }>;
             };
         }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
             beforeCreate?: (() => void) | (() => void)[];
@@ -54,9 +140,52 @@ declare const _default: {
     } & Readonly<import("vue").ExtractPropTypes<{
         "v-model": {
             type: import("vue").PropType<string>;
+            required: false;
         };
         modelValue: {
             type: import("vue").PropType<string>;
+            required: false;
+        };
+        name: <TName extends string>(n?: TName) => { [key in import("../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
+            type: import("vue").PropType<string>;
+            required: false;
+        }; } & { [key_1 in import("../DefineVueTypings").VModelKeyNameInProps<TName>]: {
+            type: import("vue").PropType<string>;
+            required: false;
+        }; } & {
+            require(): import("../DefineVueTypings").DefinePropModelRequire<TName, string, {
+                "v-model": {
+                    type: import("vue").PropType<string>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: import("vue").PropType<string>;
+                    required: false;
+                };
+            }>;
+            defaultValue(value?: string): import("../DefineVueTypings").DefinePropModelDefaultValue<TName, string, {
+                "v-model": {
+                    type: import("vue").PropType<string>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: import("vue").PropType<string>;
+                    required: false;
+                };
+            }, false>;
+            doc$(description?: string): import("../DefineVueTypings").DefinePropModelDoc<TName, string, {
+                "v-model": {
+                    type: import("vue").PropType<string>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: import("vue").PropType<string>;
+                    required: false;
+                };
+            }>;
         };
     }>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: never;
@@ -65,12 +194,100 @@ declare const _default: {
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
     "v-model": {
         type: import("vue").PropType<string>;
+        required: false;
     };
     modelValue: {
         type: import("vue").PropType<string>;
+        required: false;
+    };
+    name: <TName extends string>(n?: TName) => { [key in import("../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
+        type: import("vue").PropType<string>;
+        required: false;
+    }; } & { [key_1 in import("../DefineVueTypings").VModelKeyNameInProps<TName>]: {
+        type: import("vue").PropType<string>;
+        required: false;
+    }; } & {
+        require(): import("../DefineVueTypings").DefinePropModelRequire<TName, string, {
+            "v-model": {
+                type: import("vue").PropType<string>;
+                required: false;
+            };
+        } & {
+            modelValue: {
+                type: import("vue").PropType<string>;
+                required: false;
+            };
+        }>;
+        defaultValue(value?: string): import("../DefineVueTypings").DefinePropModelDefaultValue<TName, string, {
+            "v-model": {
+                type: import("vue").PropType<string>;
+                required: false;
+            };
+        } & {
+            modelValue: {
+                type: import("vue").PropType<string>;
+                required: false;
+            };
+        }, false>;
+        doc$(description?: string): import("../DefineVueTypings").DefinePropModelDoc<TName, string, {
+            "v-model": {
+                type: import("vue").PropType<string>;
+                required: false;
+            };
+        } & {
+            modelValue: {
+                type: import("vue").PropType<string>;
+                required: false;
+            };
+        }>;
     };
 }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Readonly<{} & {
+        name?: {
+            [x: `v-model:${string}`]: {
+                type: import("vue").PropType<string>;
+                required: false;
+            };
+        } & {
+            [x: string]: {
+                type: import("vue").PropType<string>;
+                required: false;
+            };
+        } & {
+            require(): import("../DefineVueTypings").DefinePropModelRequire<string, string, {
+                "v-model": {
+                    type: import("vue").PropType<string>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: import("vue").PropType<string>;
+                    required: false;
+                };
+            }>;
+            defaultValue(value?: string): import("../DefineVueTypings").DefinePropModelDefaultValue<string, string, {
+                "v-model": {
+                    type: import("vue").PropType<string>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: import("vue").PropType<string>;
+                    required: false;
+                };
+            }, false>;
+            doc$(description?: string): import("../DefineVueTypings").DefinePropModelDoc<string, string, {
+                "v-model": {
+                    type: import("vue").PropType<string>;
+                    required: false;
+                };
+            } & {
+                modelValue: {
+                    type: import("vue").PropType<string>;
+                    required: false;
+                };
+            }>;
+        };
         "v-model"?: string;
         modelValue?: string;
     }>;

package/internal-do-not-import-from-here/ux/compositiontests/stores/useNewStoreTest.d.ts

@@ -1,20 +1,12 @@
 export declare const useTestNewStore: (newInstanceWithName?: string) => {
     state: {
-        title: string;
-        visible: boolean;
-    };
-    get: {
-        title: () => string;
-    };
-    actions: {
-        updateTitle: (newTitle: string) => void;
-        bindVisible: import("vue").WritableComputedRef<boolean>;
+        title: number;
     };
+    get: {};
+    actions: {};
     events: {
-        onMutatingTitle: import("internal/fx/core").EventHook<string>;
-        onMutatedTitle: import("internal/fx/core").EventHook<string>;
-        onMutatingVisible: import("internal/fx/core").EventHook<boolean>;
-        onMutatedVisible: import("internal/fx/core").EventHook<boolean>;
+        onMutatingTitle: import("@omnia/fx").EventHook<number>;
+        onMutatedTitle: import("@omnia/fx").EventHook<number>;
     };
     activated: void;
 };