@quidgest/ui 0.15.2 → 0.15.3

package/esm/components/QPropertyList/QPropertyListRow.vue.js

@@ -1,10 +1,10 @@
-import { defineComponent as g, mergeModels as d, useModel as k, computed as o, createElementBlock as p, openBlock as r, normalizeClass as c, createElementVNode as n, withModifiers as u, toDisplayString as B, renderSlot as M, createCommentVNode as b, createBlock as h, resolveDynamicComponent as w, mergeProps as P } from "vue";
+import { defineComponent as V, mergeModels as p, useModel as k, computed as o, createElementBlock as c, openBlock as r, normalizeClass as u, createElementVNode as n, withModifiers as m, toDisplayString as h, renderSlot as B, createCommentVNode as M, createBlock as b, resolveDynamicComponent as P, mergeProps as w } from "vue";
 const D = ["id", "data-group"], E = {
   key: 0,
   class: "q-property-list-field__container"
-}, N = /* @__PURE__ */ g({
+}, N = /* @__PURE__ */ V({
   __name: "QPropertyListRow",
-  props: /* @__PURE__ */ d({
+  props: /* @__PURE__ */ p({
     id: {},
     class: {},
     field: {},
@@ -13,9 +13,9 @@ const D = ["id", "data-group"], E = {
     modelValue: {},
     modelModifiers: {}
   }),
-  emits: /* @__PURE__ */ d(["focus"], ["update:modelValue"]),
-  setup(a, { emit: m }) {
-    const e = a, f = m, t = k(a, "modelValue"), _ = o(() => ["q-property-list__row", e.class]), y = o(() => {
+  emits: /* @__PURE__ */ p(["focus", "field-change"], ["update:modelValue"]),
+  setup(i, { emit: f }) {
+    const e = i, a = f, t = k(i, "modelValue"), _ = o(() => ["q-property-list__row", e.class]), y = o(() => {
       var l;
       return [
         "q-property-list__cell",
@@ -24,33 +24,33 @@ const D = ["id", "data-group"], E = {
           "q-property-list__cell--required": (l = e.field.props) == null ? void 0 : l.required
         }
       ];
-    }), v = o(() => e.readonly || (e.field.props.readonly ?? !1)), V = o(() => ({
+    }), v = o(() => e.readonly || (e.field.props.readonly ?? !1)), g = o(() => ({
       ...e.field.props,
       readonly: v.value
     }));
     function s() {
-      f("focus", e.field);
+      a("focus", e.field);
     }
     function q(l) {
-      t.value = l;
+      t.value = l, a("field-change", l);
     }
-    return (l, i) => (r(), p("tr", {
+    return (l, d) => (r(), c("tr", {
       id: e.id,
-      class: c(_.value),
+      class: u(_.value),
       "data-group": e.field.group,
       onFocusin: s
     }, [
       n(
         "td",
         {
-          class: c(y.value),
-          onClick: u(s, ["prevent", "stop"])
+          class: u(y.value),
+          onClick: m(s, ["prevent", "stop"])
         },
         [
           n(
             "div",
             null,
-            B(e.field.label),
+            h(e.field.label),
             1
             /* TEXT */
           )
@@ -60,18 +60,18 @@ const D = ["id", "data-group"], E = {
       ),
       n("td", {
         class: "q-property-list__cell",
-        onClick: u(s, ["prevent", "stop"])
+        onClick: m(s, ["prevent", "stop"])
       }, [
-        M(l.$slots, "default", {}, () => [
-          e.field.component ? (r(), p("div", E, [
-            (r(), h(w(e.field.component), P(V.value, {
+        B(l.$slots, "default", {}, () => [
+          e.field.component ? (r(), c("div", E, [
+            (r(), b(P(e.field.component), w(g.value, {
               modelValue: t.value,
               "onUpdate:modelValue": [
-                i[0] || (i[0] = (C) => t.value = C),
+                d[0] || (d[0] = (C) => t.value = C),
                 q
               ]
             }), null, 16, ["modelValue"]))
-          ])) : b("v-if", !0)
+          ])) : M("v-if", !0)
         ])
       ])
     ], 42, D));

package/esm/components/QPropertyList/index.d.ts

@@ -67,11 +67,15 @@ declare const QPropertyListRow: <T>(__VLS_props: NonNullable<Awaited<typeof __VL
         default?(_: {}): any;
     };
     attrs: any;
-    emit: ((e: "focus", field: import('./types').QPropertyListField) => void) & ((evt: "update:modelValue", value: T) => void);
+    emit: {
+        (e: "focus", field: import('./types').QPropertyListField): void;
+        (e: "field-change", value: unknown): void;
+    } & ((evt: "update:modelValue", value: T) => void);
 }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: {
         readonly onFocus?: ((field: import('./types').QPropertyListField) => any) | undefined;
         readonly "onUpdate:modelValue"?: ((value: T) => any) | undefined;
+        readonly "onField-change"?: ((value: unknown) => any) | undefined;
         modelValue?: T | undefined;
         id?: string | undefined;
         class?: string | unknown[] | undefined;
@@ -83,7 +87,10 @@ declare const QPropertyListRow: <T>(__VLS_props: NonNullable<Awaited<typeof __VL
     slots: {
         default?(_: {}): any;
     };
-    emit: ((e: "focus", field: import('./types').QPropertyListField) => void) & ((evt: "update:modelValue", value: T) => void);
+    emit: {
+        (e: "focus", field: import('./types').QPropertyListField): void;
+        (e: "field-change", value: unknown): void;
+    } & ((evt: "update:modelValue", value: T) => void);
 }>) => import('vue').VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/esm/components/QPropertyList/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QPropertyList/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACX,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,uBAAuB,EACvB,MAAM,SAAS,CAAA;AAKhB,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAkC,CAAA;AACrD,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;2BAc2iN,KAAK;;;;;;cAA4J,KAAK;SAAiB,CAAC;CAd9rN,CAAA;AAC3D,QAAA,MAAM,kBAAkB;;;;;;6FAAuC,CAAA;AAC/D,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;EAAuC,CAAA;AAG/D,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,CAAA;AAGlF,YAAY,EACX,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,uBAAuB,EACvB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QPropertyList/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACX,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,uBAAuB,EACvB,MAAM,SAAS,CAAA;AAKhB,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAkC,CAAA;AACrD,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;2BAcisN,KAAK;;;;;;;;;cAA4J,KAAK;SAAiB,CAAC;CAdp1N,CAAA;AAC3D,QAAA,MAAM,kBAAkB;;;;;;6FAAuC,CAAA;AAC/D,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;EAAuC,CAAA;AAG/D,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,CAAA;AAGlF,YAAY,EACX,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,uBAAuB,EACvB,CAAA"}

package/esm/components/QRadioGroup/QRadioButton.d.ts

@@ -0,0 +1,24 @@
+import { QRadioButtonProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<QRadioButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<QRadioButtonProps> & Readonly<{}>, {
+    size: import('./types').QRadioButtonSize;
+    color: string;
+    labelPlacement: import('./types').QRadioButtonLabelPlacement;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=QRadioButton.vue.d.ts.map

package/esm/components/QRadioGroup/QRadioButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QRadioButton.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QRadioGroup/QRadioButton.vue"],"names":[],"mappings":"AA2BA;AA0FC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAmDjD,iBAAS,cAAc;WAiET,OAAO,IAA6B;;yBAZrB,GAAG;yBACH,GAAG;;;;EAgB/B;AAcD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;6EAOnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/esm/components/QRadioGroup/QRadioButton.vue.js

@@ -0,0 +1,78 @@
+import { defineComponent as m, computed as r, createBlock as b, openBlock as f, unref as o, normalizeClass as v, createSlots as y, withCtx as d, createElementVNode as g, renderSlot as i, createCommentVNode as q, mergeProps as B } from "vue";
+import { QLabel as h } from "../QLabel/index.js";
+import { useGroupItem as C } from "../../composables/group.js";
+import { useId as k } from "../../composables/uid.js";
+const z = ["id", "checked", "name", "value", "disabled"], w = /* @__PURE__ */ m({
+  inheritAttrs: !1,
+  __name: "QRadioButton",
+  props: {
+    id: {},
+    class: {},
+    label: {},
+    for: {},
+    required: { type: Boolean },
+    labelPlacement: { default: "end" },
+    disabled: { type: Boolean },
+    readonly: { type: Boolean },
+    color: { default: "primary" },
+    value: {},
+    size: { default: "regular" },
+    invalid: { type: Boolean },
+    name: {}
+  },
+  setup(s) {
+    const e = s, n = k(e.id), t = C(e.value);
+    if (!t)
+      throw new Error("QRadioButton must be used inside a QRadioGroup");
+    const u = r(() => e.labelPlacement === "start" ? "append" : "prepend"), p = r(() => {
+      const a = e.size !== "regular" ? `q-radio-button--${e.size}` : void 0, l = e.color !== "primary" ? `q-radio-button--${e.color}` : void 0;
+      return [
+        "q-radio-button",
+        a,
+        l,
+        {
+          "q-radio-button--readonly": e.readonly,
+          "q-radio-button--disabled": e.disabled,
+          "q-radio-button--invalid": e.invalid
+        },
+        e.class
+      ];
+    });
+    return (a, l) => (f(), b(o(h), {
+      for: o(n),
+      class: v(p.value),
+      label: e.label
+    }, y({
+      [u.value]: d(() => [
+        g("input", B({
+          id: o(n),
+          checked: o(t).isActive.value,
+          tabindex: "0",
+          type: "radio",
+          "aria-hidden": "true",
+          class: "q-radio-button__input",
+          name: e.name,
+          value: a.value,
+          disabled: e.readonly || e.disabled
+        }, a.$attrs, {
+          onChange: l[0] || (l[0] = //@ts-ignore
+          (...c) => o(t).toggle && o(t).toggle(...c))
+        }), null, 16, z),
+        e.labelPlacement === "end" ? i(a.$slots, "default", { key: 0 }) : q("v-if", !0)
+      ]),
+      _: 2
+      /* DYNAMIC */
+    }, [
+      e.labelPlacement === "start" ? {
+        name: "prepend",
+        fn: d(() => [
+          i(a.$slots, "default")
+        ]),
+        key: "0"
+      } : void 0
+    ]), 1032, ["for", "class", "label"]));
+  }
+});
+export {
+  w as default
+};

package/esm/components/QRadioGroup/QRadioButton.vue2.js

@@ -0,0 +1,4 @@
+import f from "./QRadioButton.vue.js";
+export {
+  f as default
+};

package/esm/components/QRadioGroup/QRadioGroup.d.ts

@@ -0,0 +1,32 @@
+import { Primitive } from '../../types/primitive';
+import { QRadioGroupProps } from './types';
+type __VLS_Props = QRadioGroupProps;
+type __VLS_PublicProps = {
+    modelValue?: Primitive;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        extras?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: Primitive) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: Primitive) => any) | undefined;
+}>, {
+    size: import('./types').QRadioButtonSize;
+    orientation: import('./types').QRadioButtonOrientation;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=QRadioGroup.vue.d.ts.map

package/esm/components/QRadioGroup/QRadioGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QRadioGroup.vue.d.ts","sourceRoot":"","sources":["../../../src/components/QRadioGroup/QRadioGroup.vue"],"names":[],"mappings":"AAsBA;AA8FC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAK/C,KAAK,WAAW,GAAG,gBAAgB,CAAC;AAoDrC,KAAK,iBAAiB,GAAG;IACzB,UAAU,CAAC,EAAE,SAAS,CAAC;CACtB,GAAG,WAAW,CAAC;AAKhB,iBAAS,cAAc;WAqDT,OAAO,IAA6B;;yBAZrB,GAAG;wBACJ,GAAG;;;;EAgB9B;AAaD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe;;;;;;;6EAQnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAapG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/esm/components/QRadioGroup/QRadioGroup.vue.js

@@ -0,0 +1,79 @@
+import { defineComponent as b, mergeModels as y, useModel as g, watch as B, computed as d, toRef as r, createElementBlock as n, openBlock as a, normalizeClass as q, createBlock as _, createCommentVNode as u, createElementVNode as h, unref as l, mergeProps as z, renderSlot as m } from "vue";
+import { QLabel as k } from "../QLabel/index.js";
+import { provideDefaults as V } from "../../composables/defaults.js";
+import { useGroup as $ } from "../../composables/group.js";
+import { useId as c } from "../../composables/uid.js";
+const C = ["id"], M = {
+  key: 1,
+  class: "q-field__extras"
+}, w = /* @__PURE__ */ b({
+  inheritAttrs: !1,
+  __name: "QRadioGroup",
+  props: /* @__PURE__ */ y({
+    id: {},
+    class: {},
+    label: {},
+    for: {},
+    required: { type: Boolean },
+    orientation: { default: "vertical" },
+    disabled: { type: Boolean },
+    readonly: { type: Boolean },
+    size: { default: "regular" },
+    invalid: { type: Boolean },
+    name: {}
+  }, {
+    modelValue: { type: [String, Number, Boolean, Symbol] },
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(t) {
+    const e = t, i = g(t, "modelValue"), { active: p } = $({ active: i });
+    B(p, (o) => {
+      i.value = o;
+    });
+    const s = c(e.id), f = d(() => c(e.name)), v = d(() => [
+      "q-radio-group",
+      {
+        "q-radio-group--horizontal": e.orientation === "horizontal"
+      },
+      e.class
+    ]);
+    return V({
+      QRadioButton: {
+        size: r(e, "size"),
+        disabled: r(e, "disabled"),
+        readonly: r(e, "readonly"),
+        invalid: r(e, "invalid"),
+        name: f
+      }
+    }), (o, N) => (a(), n(
+      "div",
+      {
+        class: q(v.value)
+      },
+      [
+        e.label ? (a(), _(l(k), {
+          key: 0,
+          for: l(s),
+          label: e.label,
+          required: e.required
+        }, null, 8, ["for", "label", "required"])) : u("v-if", !0),
+        h("div", z({
+          id: l(s),
+          class: "q-radio-group__group",
+          role: "radiogroup"
+        }, o.$attrs), [
+          m(o.$slots, "default")
+        ], 16, C),
+        o.$slots.extras ? (a(), n("div", M, [
+          m(o.$slots, "extras")
+        ])) : u("v-if", !0)
+      ],
+      2
+      /* CLASS */
+    ));
+  }
+});
+export {
+  w as default
+};

package/esm/components/QRadioGroup/QRadioGroup.vue2.js

@@ -0,0 +1,4 @@
+import f from "./QRadioGroup.vue.js";
+export {
+  f as default
+};

package/esm/components/QRadioGroup/index.d.ts

@@ -0,0 +1,108 @@
+declare const QRadioButton: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('./types').QRadioButtonProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        size: import('./types').QRadioButtonSize;
+        color: string;
+        labelPlacement: import('./types').QRadioButtonLabelPlacement;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('./types').QRadioButtonProps> & Readonly<{}>, {}, {}, {}, {}, {
+        size: import('./types').QRadioButtonSize;
+        color: string;
+        labelPlacement: import('./types').QRadioButtonLabelPlacement;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('./types').QRadioButtonProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+    size: import('./types').QRadioButtonSize;
+    color: string;
+    labelPlacement: import('./types').QRadioButtonLabelPlacement;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+    };
+});
+declare const QRadioGroup: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        modelValue?: import('../../types/primitive').Primitive;
+    } & import('../../types/component').QBaseComponentProps & {
+        label?: string;
+        for?: string;
+        required?: boolean;
+    } & {
+        orientation?: import('./types').QRadioButtonOrientation;
+        disabled?: boolean;
+        readonly?: boolean;
+        size?: import('./types').QRadioButtonSize;
+        invalid?: boolean;
+        name?: string;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: import('../../types/primitive').Primitive) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:modelValue": (value: import('../../types/primitive').Primitive) => any;
+    }, import('vue').PublicProps, {
+        size: import('./types').QRadioButtonSize;
+        orientation: import('./types').QRadioButtonOrientation;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        modelValue?: import('../../types/primitive').Primitive;
+    } & import('../../types/component').QBaseComponentProps & {
+        label?: string;
+        for?: string;
+        required?: boolean;
+    } & {
+        orientation?: import('./types').QRadioButtonOrientation;
+        disabled?: boolean;
+        readonly?: boolean;
+        size?: import('./types').QRadioButtonSize;
+        invalid?: boolean;
+        name?: string;
+    }> & Readonly<{
+        "onUpdate:modelValue"?: ((value: import('../../types/primitive').Primitive) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        size: import('./types').QRadioButtonSize;
+        orientation: import('./types').QRadioButtonOrientation;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<{
+    modelValue?: import('../../types/primitive').Primitive;
+} & import('../../types/component').QBaseComponentProps & {
+    label?: string;
+    for?: string;
+    required?: boolean;
+} & {
+    orientation?: import('./types').QRadioButtonOrientation;
+    disabled?: boolean;
+    readonly?: boolean;
+    size?: import('./types').QRadioButtonSize;
+    invalid?: boolean;
+    name?: string;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: import('../../types/primitive').Primitive) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: import('../../types/primitive').Primitive) => any;
+}, string, {
+    size: import('./types').QRadioButtonSize;
+    orientation: import('./types').QRadioButtonOrientation;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+        extras?(_: {}): any;
+    };
+});
+export { QRadioButton, QRadioGroup };
+//# sourceMappingURL=index.d.ts.map

package/esm/components/QRadioGroup/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QRadioGroup/index.ts"],"names":[],"mappings":"AAOA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiC,CAAA;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAgC,CAAA;AAGjD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,CAAA"}

package/esm/components/QRadioGroup/index.js

@@ -0,0 +1,8 @@
+import r from "./QRadioButton.vue.js";
+import t from "./QRadioGroup.vue.js";
+import { setupPropsProxy as o } from "../../utils/setupPropsProxy.js";
+const s = o(r), f = o(t);
+export {
+  s as QRadioButton,
+  f as QRadioGroup
+};

package/esm/components/QRadioGroup/types.d.ts

@@ -0,0 +1,65 @@
+import { QLabelProps } from '../QLabel';
+export type QRadioButtonOrientation = 'vertical' | 'horizontal';
+export type QRadioButtonSize = 'small' | 'regular' | 'large';
+export type QRadioGroupProps = QLabelProps & {
+    /**
+     * The orientation of the radio button group shown.
+     */
+    orientation?: QRadioButtonOrientation;
+    /**
+     * If true, the radio button is disabled and cannot be interacted with.
+     */
+    disabled?: boolean;
+    /**
+     * If set to true, the radio button is read-only.
+     */
+    readonly?: boolean;
+    /**
+     * The size of the checkbox, either 'regular', 'small' or 'large'.
+     */
+    size?: QRadioButtonSize;
+    /**
+     * Indicates whether the provided value fails the validation criteria.
+     */
+    invalid?: boolean;
+    /**
+     * The name for each radio buttons in radio group.
+     */
+    name?: string;
+};
+export type QRadioButtonLabelPlacement = 'start' | 'end';
+export type QRadioButtonProps = QLabelProps & {
+    /**
+     * The placement of the label shown.
+     */
+    labelPlacement?: QRadioButtonLabelPlacement;
+    /**
+     * If true, the radio button is disabled and cannot be interacted with.
+     */
+    disabled?: boolean;
+    /**
+     * If set to true, the radio button is read-only.
+     */
+    readonly?: boolean;
+    /**
+     * Applies specified color to the control
+     */
+    color?: string;
+    /**
+     * Defined the value for the radio button.
+     */
+    value: string;
+    /**
+     * The size of the checkbox, either 'regular', 'small' or 'large'.
+     */
+    size?: QRadioButtonSize;
+    /**
+     * Indicates whether the provided value fails the validation criteria.
+     */
+    invalid?: boolean;
+    /**
+     * The name for each radio buttons in radio group.
+     */
+    name?: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/esm/components/QRadioGroup/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/components/QRadioGroup/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,MAAM,MAAM,uBAAuB,GAAG,UAAU,GAAG,YAAY,CAAA;AAE/D,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,CAAA;AAE5D,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG;IAC5C;;OAEG;IACH,WAAW,CAAC,EAAE,uBAAuB,CAAA;IAErC;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;OAEG;IACH,IAAI,CAAC,EAAE,gBAAgB,CAAA;IAEvB;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG,OAAO,GAAG,KAAK,CAAA;AAExD,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG;IAC7C;;OAEG;IACH,cAAc,CAAC,EAAE,0BAA0B,CAAA;IAE3C;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd;;OAEG;IACH,KAAK,EAAE,MAAM,CAAA;IAEb;;OAEG;IACH,IAAI,CAAC,EAAE,gBAAgB,CAAA;IAEvB;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;CACb,CAAA"}

package/esm/components/QSelect/QSelect.d.ts

@@ -26,10 +26,10 @@ declare function __VLS_template(): {
                 readonly class?: string | unknown[] | undefined;
                 readonly label?: string | undefined;
                 readonly for?: string | undefined;
+                readonly required?: boolean | undefined;
                 readonly size?: import('../QField').QFieldSize | undefined;
                 readonly readonly?: boolean | undefined;
                 readonly disabled?: boolean | undefined;
-                readonly required?: boolean | undefined;
                 readonly invalid?: boolean | undefined;
             } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
             $attrs: {
@@ -298,10 +298,10 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
             readonly class?: string | unknown[] | undefined;
             readonly label?: string | undefined;
             readonly for?: string | undefined;
+            readonly required?: boolean | undefined;
             readonly size?: import('../QField').QFieldSize | undefined;
             readonly readonly?: boolean | undefined;
             readonly disabled?: boolean | undefined;
-            readonly required?: boolean | undefined;
             readonly invalid?: boolean | undefined;
         } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
         $attrs: {

package/esm/components/QSelect/QSelect.vue.js

@@ -25,10 +25,10 @@ const fe = {
     class: {},
     label: {},
     for: {},
+    required: { type: Boolean },
     size: {},
     readonly: { type: Boolean },
     disabled: { type: Boolean },
-    required: { type: Boolean },
     invalid: { type: Boolean },
     items: {},
     groups: { default: () => [] },

package/esm/components/QSelect/index.d.ts

@@ -4,6 +4,7 @@ declare const QSelect: {
     } & import('../../types/component').QBaseComponentProps & {
         label?: string;
         for?: string;
+        required?: boolean;
     } & {
         size?: import('..').QFieldSize;
         readonly?: boolean;
@@ -54,10 +55,10 @@ declare const QSelect: {
                 readonly class?: string | unknown[] | undefined;
                 readonly label?: string | undefined;
                 readonly for?: string | undefined;
+                readonly required?: boolean | undefined;
                 readonly size?: import('..').QFieldSize | undefined;
                 readonly readonly?: boolean | undefined;
                 readonly disabled?: boolean | undefined;
-                readonly required?: boolean | undefined;
                 readonly invalid?: boolean | undefined;
             } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
             $attrs: {
@@ -304,6 +305,7 @@ declare const QSelect: {
     } & import('../../types/component').QBaseComponentProps & {
         label?: string;
         for?: string;
+        required?: boolean;
     } & {
         size?: import('..').QFieldSize;
         readonly?: boolean;
@@ -347,6 +349,7 @@ declare const QSelect: {
 } & import('../../types/component').QBaseComponentProps & {
     label?: string;
     for?: string;
+    required?: boolean;
 } & {
     size?: import('..').QFieldSize;
     readonly?: boolean;

package/esm/components/QSelect/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QSelect/index.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAI2wzB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAJr2zB,CAAA;AAGzC,OAAO,EAAE,OAAO,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/QSelect/index.ts"],"names":[],"mappings":"AAMA,QAAA,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAI2wzB,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAtH,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAJr2zB,CAAA;AAGzC,OAAO,EAAE,OAAO,EAAE,CAAA"}

package/esm/components/QTextArea/QTextArea.vue.js

@@ -10,10 +10,10 @@ const H = ["id", "required", "placeholder", "readonly", "disabled", "maxlength",
     class: {},
     label: {},
     for: {},
+    required: { type: Boolean },
     size: {},
     readonly: { type: Boolean },
     disabled: { type: Boolean },
-    required: { type: Boolean },
     invalid: { type: Boolean },
     placeholder: {},
     maxLength: {},