@jari-ace/element-plus-component 0.3.2 → 0.3.3

package/dist/components/radioGroup/JaRadioGroup.vue.d.ts

@@ -1,64 +1,31 @@
+import type { EpPropMergeType } from "element-plus/es/utils";
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {
     focus: () => any;
     blur: () => any;
-    elRadioGroup: import("vue").Ref<{
+    elRadioGroup: import("vue").Ref<import("element-plus/es/utils/index.mjs").SFCWithInstall<{
         new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
             readonly ariaLabel: StringConstructor;
-            readonly id: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
+            readonly id: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
             readonly size: {
-                readonly type: import("vue").PropType<"" | "default" | "small" | "large">;
+                readonly type: import("vue").PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
                 readonly required: false;
                 readonly validator: (val: unknown) => boolean;
                 __epPropKey: true;
             };
             readonly disabled: BooleanConstructor;
-            readonly modelValue: {
-                readonly type: import("vue").PropType<string | number | boolean>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly fill: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-            readonly textColor: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-            readonly name: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly validateEvent: {
-                readonly type: import("vue").PropType<boolean>;
+            readonly modelValue: import("element-plus/es/utils/index.mjs").EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+            readonly fill: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly textColor: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly name: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly validateEvent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly options: {
+                readonly type: import("vue").PropType<any[]>;
                 readonly required: false;
                 readonly validator: (val: unknown) => boolean;
                 __epPropKey: true;
-            } & {
-                readonly default: true;
             };
+            readonly props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").radioOptionProp) | (() => import("element-plus").radioOptionProp) | ((new (...args: any[]) => import("element-plus").radioOptionProp) | (() => import("element-plus").radioOptionProp))[], unknown, unknown, () => Required<import("element-plus").radioOptionProp>, boolean>;
+            readonly type: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, "button" | "radio", unknown, "radio", boolean>;
         }>> & {
             "onUpdate:modelValue"?: (val: string | number | boolean) => any;
             onChange?: (val: string | number | boolean) => any;
@@ -69,9 +36,11 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {
             readonly disabled: boolean;
             readonly fill: string;
             readonly id: string;
+            readonly type: EpPropMergeType<StringConstructor, "button" | "radio", unknown>;
+            readonly props: import("element-plus").radioOptionProp;
             readonly name: string;
-            readonly modelValue: string | number | boolean;
-            readonly validateEvent: boolean;
+            readonly modelValue: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
+            readonly validateEvent: EpPropMergeType<BooleanConstructor, unknown, unknown>;
             readonly textColor: string;
         }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
             P: {};
@@ -82,61 +51,27 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {
             Defaults: {};
         }, Readonly<import("vue").ExtractPropTypes<{
             readonly ariaLabel: StringConstructor;
-            readonly id: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
+            readonly id: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
             readonly size: {
-                readonly type: import("vue").PropType<"" | "default" | "small" | "large">;
+                readonly type: import("vue").PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
                 readonly required: false;
                 readonly validator: (val: unknown) => boolean;
                 __epPropKey: true;
             };
             readonly disabled: BooleanConstructor;
-            readonly modelValue: {
-                readonly type: import("vue").PropType<string | number | boolean>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly fill: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-            readonly textColor: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-            readonly name: {
-                readonly type: import("vue").PropType<string>;
+            readonly modelValue: import("element-plus/es/utils/index.mjs").EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+            readonly fill: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly textColor: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly name: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly validateEvent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly options: {
+                readonly type: import("vue").PropType<any[]>;
                 readonly required: false;
                 readonly validator: (val: unknown) => boolean;
                 __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly validateEvent: {
-                readonly type: import("vue").PropType<boolean>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: true;
             };
+            readonly props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").radioOptionProp) | (() => import("element-plus").radioOptionProp) | ((new (...args: any[]) => import("element-plus").radioOptionProp) | (() => import("element-plus").radioOptionProp))[], unknown, unknown, () => Required<import("element-plus").radioOptionProp>, boolean>;
+            readonly type: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, "button" | "radio", unknown, "radio", boolean>;
         }>> & {
             "onUpdate:modelValue"?: (val: string | number | boolean) => any;
             onChange?: (val: string | number | boolean) => any;
@@ -144,9 +79,11 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {
             readonly disabled: boolean;
             readonly fill: string;
             readonly id: string;
+            readonly type: EpPropMergeType<StringConstructor, "button" | "radio", unknown>;
+            readonly props: import("element-plus").radioOptionProp;
             readonly name: string;
-            readonly modelValue: string | number | boolean;
-            readonly validateEvent: boolean;
+            readonly modelValue: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
+            readonly validateEvent: EpPropMergeType<BooleanConstructor, unknown, unknown>;
             readonly textColor: string;
         }>;
         __isFragment?: never;
@@ -154,61 +91,27 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {
         __isSuspense?: never;
     } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
         readonly ariaLabel: StringConstructor;
-        readonly id: {
-            readonly type: import("vue").PropType<string>;
-            readonly required: false;
-            readonly validator: (val: unknown) => boolean;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
+        readonly id: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
         readonly size: {
-            readonly type: import("vue").PropType<"" | "default" | "small" | "large">;
+            readonly type: import("vue").PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
             readonly required: false;
             readonly validator: (val: unknown) => boolean;
             __epPropKey: true;
         };
         readonly disabled: BooleanConstructor;
-        readonly modelValue: {
-            readonly type: import("vue").PropType<string | number | boolean>;
-            readonly required: false;
-            readonly validator: (val: unknown) => boolean;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        readonly fill: {
-            readonly type: import("vue").PropType<string>;
-            readonly required: false;
-            readonly validator: (val: unknown) => boolean;
-            __epPropKey: true;
-        } & {
-            readonly default: "";
-        };
-        readonly textColor: {
-            readonly type: import("vue").PropType<string>;
-            readonly required: false;
-            readonly validator: (val: unknown) => boolean;
-            __epPropKey: true;
-        } & {
-            readonly default: "";
-        };
-        readonly name: {
-            readonly type: import("vue").PropType<string>;
-            readonly required: false;
-            readonly validator: (val: unknown) => boolean;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        readonly validateEvent: {
-            readonly type: import("vue").PropType<boolean>;
+        readonly modelValue: import("element-plus/es/utils/index.mjs").EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+        readonly fill: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly textColor: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly name: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+        readonly validateEvent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly options: {
+            readonly type: import("vue").PropType<any[]>;
             readonly required: false;
             readonly validator: (val: unknown) => boolean;
             __epPropKey: true;
-        } & {
-            readonly default: true;
         };
+        readonly props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").radioOptionProp) | (() => import("element-plus").radioOptionProp) | ((new (...args: any[]) => import("element-plus").radioOptionProp) | (() => import("element-plus").radioOptionProp))[], unknown, unknown, () => Required<import("element-plus").radioOptionProp>, boolean>;
+        readonly type: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, "button" | "radio", unknown, "radio", boolean>;
     }>> & {
         "onUpdate:modelValue"?: (val: string | number | boolean) => any;
         onChange?: (val: string | number | boolean) => any;
@@ -219,72 +122,40 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {
         readonly disabled: boolean;
         readonly fill: string;
         readonly id: string;
+        readonly type: EpPropMergeType<StringConstructor, "button" | "radio", unknown>;
+        readonly props: import("element-plus").radioOptionProp;
         readonly name: string;
-        readonly modelValue: string | number | boolean;
-        readonly validateEvent: boolean;
+        readonly modelValue: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
+        readonly validateEvent: EpPropMergeType<BooleanConstructor, unknown, unknown>;
         readonly textColor: string;
-    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & (import("vue").VNodeProps & (import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & ((new () => {
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
         $slots: {
             default?(_: {}): any;
         };
-    }) & import("vue").Plugin))), {
+    })>, import("element-plus/es/utils/index.mjs").SFCWithInstall<{
         new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
             readonly ariaLabel: StringConstructor;
-            readonly id: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
+            readonly id: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
             readonly size: {
-                readonly type: import("vue").PropType<"" | "default" | "small" | "large">;
+                readonly type: import("vue").PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
                 readonly required: false;
                 readonly validator: (val: unknown) => boolean;
                 __epPropKey: true;
             };
             readonly disabled: BooleanConstructor;
-            readonly modelValue: {
-                readonly type: import("vue").PropType<string | number | boolean>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly fill: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-            readonly textColor: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-            readonly name: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly validateEvent: {
-                readonly type: import("vue").PropType<boolean>;
+            readonly modelValue: import("element-plus/es/utils/index.mjs").EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+            readonly fill: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly textColor: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly name: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly validateEvent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly options: {
+                readonly type: import("vue").PropType<any[]>;
                 readonly required: false;
                 readonly validator: (val: unknown) => boolean;
                 __epPropKey: true;
-            } & {
-                readonly default: true;
             };
+            readonly props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").radioOptionProp) | (() => import("element-plus").radioOptionProp) | ((new (...args: any[]) => import("element-plus").radioOptionProp) | (() => import("element-plus").radioOptionProp))[], unknown, unknown, () => Required<import("element-plus").radioOptionProp>, boolean>;
+            readonly type: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, "button" | "radio", unknown, "radio", boolean>;
         }>> & {
             "onUpdate:modelValue"?: (val: string | number | boolean) => any;
             onChange?: (val: string | number | boolean) => any;
@@ -295,9 +166,11 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {
             readonly disabled: boolean;
             readonly fill: string;
             readonly id: string;
+            readonly type: EpPropMergeType<StringConstructor, "button" | "radio", unknown>;
+            readonly props: import("element-plus").radioOptionProp;
             readonly name: string;
-            readonly modelValue: string | number | boolean;
-            readonly validateEvent: boolean;
+            readonly modelValue: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
+            readonly validateEvent: EpPropMergeType<BooleanConstructor, unknown, unknown>;
             readonly textColor: string;
         }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
             P: {};
@@ -308,61 +181,27 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {
             Defaults: {};
         }, Readonly<import("vue").ExtractPropTypes<{
             readonly ariaLabel: StringConstructor;
-            readonly id: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
+            readonly id: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
             readonly size: {
-                readonly type: import("vue").PropType<"" | "default" | "small" | "large">;
+                readonly type: import("vue").PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
                 readonly required: false;
                 readonly validator: (val: unknown) => boolean;
                 __epPropKey: true;
             };
             readonly disabled: BooleanConstructor;
-            readonly modelValue: {
-                readonly type: import("vue").PropType<string | number | boolean>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly fill: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-            readonly textColor: {
-                readonly type: import("vue").PropType<string>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: "";
-            };
-            readonly name: {
-                readonly type: import("vue").PropType<string>;
+            readonly modelValue: import("element-plus/es/utils/index.mjs").EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+            readonly fill: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly textColor: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly name: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+            readonly validateEvent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly options: {
+                readonly type: import("vue").PropType<any[]>;
                 readonly required: false;
                 readonly validator: (val: unknown) => boolean;
                 __epPropKey: true;
-            } & {
-                readonly default: undefined;
-            };
-            readonly validateEvent: {
-                readonly type: import("vue").PropType<boolean>;
-                readonly required: false;
-                readonly validator: (val: unknown) => boolean;
-                __epPropKey: true;
-            } & {
-                readonly default: true;
             };
+            readonly props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").radioOptionProp) | (() => import("element-plus").radioOptionProp) | ((new (...args: any[]) => import("element-plus").radioOptionProp) | (() => import("element-plus").radioOptionProp))[], unknown, unknown, () => Required<import("element-plus").radioOptionProp>, boolean>;
+            readonly type: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, "button" | "radio", unknown, "radio", boolean>;
         }>> & {
             "onUpdate:modelValue"?: (val: string | number | boolean) => any;
             onChange?: (val: string | number | boolean) => any;
@@ -370,9 +209,11 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {
             readonly disabled: boolean;
             readonly fill: string;
             readonly id: string;
+            readonly type: EpPropMergeType<StringConstructor, "button" | "radio", unknown>;
+            readonly props: import("element-plus").radioOptionProp;
             readonly name: string;
-            readonly modelValue: string | number | boolean;
-            readonly validateEvent: boolean;
+            readonly modelValue: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
+            readonly validateEvent: EpPropMergeType<BooleanConstructor, unknown, unknown>;
             readonly textColor: string;
         }>;
         __isFragment?: never;
@@ -380,61 +221,27 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {
         __isSuspense?: never;
     } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
         readonly ariaLabel: StringConstructor;
-        readonly id: {
-            readonly type: import("vue").PropType<string>;
-            readonly required: false;
-            readonly validator: (val: unknown) => boolean;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
+        readonly id: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
         readonly size: {
-            readonly type: import("vue").PropType<"" | "default" | "small" | "large">;
+            readonly type: import("vue").PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
             readonly required: false;
             readonly validator: (val: unknown) => boolean;
             __epPropKey: true;
         };
         readonly disabled: BooleanConstructor;
-        readonly modelValue: {
-            readonly type: import("vue").PropType<string | number | boolean>;
-            readonly required: false;
-            readonly validator: (val: unknown) => boolean;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        readonly fill: {
-            readonly type: import("vue").PropType<string>;
-            readonly required: false;
-            readonly validator: (val: unknown) => boolean;
-            __epPropKey: true;
-        } & {
-            readonly default: "";
-        };
-        readonly textColor: {
-            readonly type: import("vue").PropType<string>;
-            readonly required: false;
-            readonly validator: (val: unknown) => boolean;
-            __epPropKey: true;
-        } & {
-            readonly default: "";
-        };
-        readonly name: {
-            readonly type: import("vue").PropType<string>;
-            readonly required: false;
-            readonly validator: (val: unknown) => boolean;
-            __epPropKey: true;
-        } & {
-            readonly default: undefined;
-        };
-        readonly validateEvent: {
-            readonly type: import("vue").PropType<boolean>;
+        readonly modelValue: import("element-plus/es/utils/index.mjs").EpPropFinalized<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown, undefined, boolean>;
+        readonly fill: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly textColor: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly name: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, unknown, unknown, undefined, boolean>;
+        readonly validateEvent: import("element-plus/es/utils/index.mjs").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly options: {
+            readonly type: import("vue").PropType<any[]>;
             readonly required: false;
             readonly validator: (val: unknown) => boolean;
             __epPropKey: true;
-        } & {
-            readonly default: true;
         };
+        readonly props: import("element-plus/es/utils/index.mjs").EpPropFinalized<(new (...args: any[]) => import("element-plus").radioOptionProp) | (() => import("element-plus").radioOptionProp) | ((new (...args: any[]) => import("element-plus").radioOptionProp) | (() => import("element-plus").radioOptionProp))[], unknown, unknown, () => Required<import("element-plus").radioOptionProp>, boolean>;
+        readonly type: import("element-plus/es/utils/index.mjs").EpPropFinalized<StringConstructor, "button" | "radio", unknown, "radio", boolean>;
     }>> & {
         "onUpdate:modelValue"?: (val: string | number | boolean) => any;
         onChange?: (val: string | number | boolean) => any;
@@ -445,15 +252,17 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{}, {
         readonly disabled: boolean;
         readonly fill: string;
         readonly id: string;
+        readonly type: EpPropMergeType<StringConstructor, "button" | "radio", unknown>;
+        readonly props: import("element-plus").radioOptionProp;
         readonly name: string;
-        readonly modelValue: string | number | boolean;
-        readonly validateEvent: boolean;
+        readonly modelValue: EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor], unknown, unknown>;
+        readonly validateEvent: EpPropMergeType<BooleanConstructor, unknown, unknown>;
         readonly textColor: string;
-    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & (import("vue").VNodeProps & (import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & ((new () => {
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
         $slots: {
             default?(_: {}): any;
         };
-    }) & import("vue").Plugin)))>;
+    })>>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     change: (value: string | number | boolean) => any;
 }, string, import("vue").PublicProps, Readonly<{}> & Readonly<{

package/dist/components/radioGroup/JaRadioGroup.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JaRadioGroup.vue.d.ts","sourceRoot":"","sources":["../../../packages/components/radioGroup/JaRadioGroup.vue"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqKA,wBAA0E;AAE1E,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}
+{"version":3,"file":"JaRadioGroup.vue.d.ts","sourceRoot":"","sources":["../../../packages/components/radioGroup/JaRadioGroup.vue"],"names":[],"mappings":"AAuDA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8G3D,wBAA0E;AAE1E,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/components/rolePicker/RoleCategorySelector.vue.d.ts

@@ -0,0 +1,14 @@
+type __VLS_Props = {
+    appId?: string;
+    allowEdit?: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & {
+    modelValue?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: string) => any;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+//# sourceMappingURL=RoleCategorySelector.vue.d.ts.map

package/dist/components/rolePicker/RoleCategorySelector.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoleCategorySelector.vue.d.ts","sourceRoot":"","sources":["../../../packages/components/rolePicker/RoleCategorySelector.vue"],"names":[],"mappings":"AAoKA,KAAK,WAAW,GAAG;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAA;CACtB,CAAC;AA0GF,KAAK,iBAAiB,GAAG,WAAW,GAAG;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;;;;;;AAuTF,wBAOG"}