sit-onyx 1.0.0-beta.26 → 1.0.0-beta.28

package/dist/components/OnyxCheckboxGroup/types.d.ts

@@ -2,7 +2,8 @@ import type { DensityProp } from "../../composables/density";
 import type { RequiredMarkerProp } from "../../composables/required";
 import type { CustomValidityProp } from "../../composables/useCustomValidity";
 import type { AutofocusProp, BaseSelectOption, Direction, SelectOptionValue } from "../../types";
-export type OnyxCheckboxGroupProps<TValue extends SelectOptionValue = SelectOptionValue> = DensityProp & Pick<BaseSelectOption, "truncation"> & {
+import type { OnyxFormElementProps } from "../OnyxFormElement/types";
+export type OnyxCheckboxGroupProps<TValue extends SelectOptionValue = SelectOptionValue> = DensityProp & Pick<BaseSelectOption, "truncation"> & Pick<OnyxFormElementProps, "label" | "hideLabel"> & {
     /**
      * Checkbox options.
      */
@@ -11,10 +12,6 @@ export type OnyxCheckboxGroupProps<TValue extends SelectOptionValue = SelectOpti
      * Currently checked checkboxes.
      */
     modelValue?: TValue[];
-    /**
-     * Headline to show above all checkboxes which is also the fieldset legend.
-     */
-    headline?: string;
     /**
      * Direction of the checkboxes.
      */

package/dist/components/OnyxErrorTooltip/OnyxErrorTooltip.vue.d.ts

@@ -0,0 +1,49 @@
+import { type FormErrorMessages } from "../../composables/useCustomValidity";
+declare function __VLS_template(): Readonly<{
+    /**
+     * Any component. Will be wrapped in an OnyxTooltip showing
+     * an  error message if an error message is set.
+     */
+    default(): unknown;
+}> & {
+    /**
+     * Any component. Will be wrapped in an OnyxTooltip showing
+     * an  error message if an error message is set.
+     */
+    default(): unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_TypePropsToOption<{
+    /**
+     * The given component will be shown inside a tooltip when
+     * errorMessages are provided. Without errorMessages, the
+     * component will not be rendered inside a slot.
+     */
+    errorMessages?: FormErrorMessages;
+    /** We don't show an error if the content is not interactive */
+    disabled?: boolean;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    /**
+     * The given component will be shown inside a tooltip when
+     * errorMessages are provided. Without errorMessages, the
+     * component will not be rendered inside a slot.
+     */
+    errorMessages?: FormErrorMessages;
+    /** We don't show an error if the content is not interactive */
+    disabled?: boolean;
+}>>>, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/OnyxNavBar/modules/OnyxFlyoutMenu/OnyxFlyoutMenu.vue.d.ts

@@ -3,12 +3,10 @@ import type { SelectOptionValue } from "../../../../types";
 import type { OnyxFlyoutMenuProps } from "./types";
 declare const _default: <TValue extends SelectOptionValue = SelectOptionValue>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_Prettify<Pick<Partial<{}> & Omit<{
-        "onUpdate:open"?: ((open: boolean) => any) | undefined;
+        "onUpdate:open"?: ((isOpen: boolean) => any) | undefined;
     } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{}>> & {
-        "onUpdate:open"?: ((open: boolean) => any) | undefined;
-    }, never>, "onUpdate:open"> & ({
-        open?: boolean;
-    } & OnyxFlyoutMenuProps)> & import("vue").PublicProps;
+        "onUpdate:open"?: ((isOpen: boolean) => any) | undefined;
+    }, never>, "onUpdate:open"> & OnyxFlyoutMenuProps> & import("vue").PublicProps;
     expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
     attrs: any;
     slots: ReturnType<() => Readonly<{
@@ -46,7 +44,7 @@ declare const _default: <TValue extends SelectOptionValue = SelectOptionValue>(_
          */
         footer?(): unknown;
     }>;
-    emit: (evt: "update:open", open: boolean) => void;
+    emit: ((evt: "update:open", isOpen: boolean) => void) & {};
 }>) => VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
 }> & {

package/dist/components/OnyxNavBar/modules/OnyxFlyoutMenu/types.d.ts

@@ -1,4 +1,10 @@
+import type { ManagedProp } from "../../../../composables/useManagedState";
 export type OnyxFlyoutMenuProps = {
+    /**
+     * If the flyout is expanded or not.
+     * If `undefined`, the state will be managed internally.
+     */
+    open?: ManagedProp<boolean>;
     /**
      * Aria label for the flyout.
      */

package/dist/components/OnyxNavBar/modules/OnyxNavButton/NavButtonLayout.vue.d.ts

@@ -1,10 +1,4 @@
-import type { OnyxNavButtonProps } from "./types";
-declare let __VLS_typeProps: OnyxNavButtonProps & {
-    isMobile: boolean;
-};
-type __VLS_PublicProps = {
-    "mobileChildrenOpen"?: boolean;
-} & typeof __VLS_typeProps;
+import { type ManagedProp } from "../../../../composables/useManagedState";
 declare function __VLS_template(): Readonly<{
     button?(): unknown;
     options?(): unknown;
@@ -12,13 +6,47 @@ declare function __VLS_template(): Readonly<{
     button?(): unknown;
     options?(): unknown;
 };
-declare const __VLS_component: import("vue").DefineComponent<__VLS_TypePropsToOption<__VLS_PublicProps>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:mobileChildrenOpen": (mobileChildrenOpen: boolean) => void;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<__VLS_PublicProps>>> & {
-    "onUpdate:mobileChildrenOpen"?: ((mobileChildrenOpen: boolean) => any) | undefined;
-}, {}, {}>;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<import("../../../OnyxExternalLinkIcon/types").OnyxExternalLinkIcon & {
+    label: string;
+    active?: boolean;
+} & {
+    isMobile: boolean;
+    /**
+     * Controls the open state for the mobile children.
+     * Is managed internally if not provided.
+     */
+    mobileChildrenOpen: ManagedProp<boolean>;
+}>, {
+    mobileChildrenOpen: symbol;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:mobileChildrenOpen": (isOpen: boolean) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<import("../../../OnyxExternalLinkIcon/types").OnyxExternalLinkIcon & {
+    label: string;
+    active?: boolean;
+} & {
+    isMobile: boolean;
+    /**
+     * Controls the open state for the mobile children.
+     * Is managed internally if not provided.
+     */
+    mobileChildrenOpen: ManagedProp<boolean>;
+}>, {
+    mobileChildrenOpen: symbol;
+}>>> & {
+    "onUpdate:mobileChildrenOpen"?: ((isOpen: boolean) => any) | undefined;
+}, {
+    mobileChildrenOpen: ManagedProp<boolean>;
+}, {}>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/OnyxNavBar/modules/OnyxUserMenu/OnyxUserMenu.vue.d.ts

@@ -1,8 +1,4 @@
 import type { OnyxUserMenuProps } from "./types";
-declare let __VLS_typeProps: OnyxUserMenuProps;
-type __VLS_PublicProps = {
-    "flyoutOpen"?: boolean;
-} & typeof __VLS_typeProps;
 declare function __VLS_template(): Readonly<{
     /**
      * Slot for the menu options. Its recommended to use the `OnyxMenuItem` component here.
@@ -22,13 +18,27 @@ declare function __VLS_template(): Readonly<{
      */
     footer?(): unknown;
 };
-declare const __VLS_component: import("vue").DefineComponent<__VLS_TypePropsToOption<__VLS_PublicProps>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:flyoutOpen": (flyoutOpen: boolean) => void;
-}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<__VLS_PublicProps>>> & {
-    "onUpdate:flyoutOpen"?: ((flyoutOpen: boolean) => any) | undefined;
-}, {}, {}>;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<OnyxUserMenuProps>, {
+    flyoutOpen: symbol;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:flyoutOpen": (isOpen: boolean) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<OnyxUserMenuProps>, {
+    flyoutOpen: symbol;
+}>>> & {
+    "onUpdate:flyoutOpen"?: ((isOpen: boolean) => any) | undefined;
+}, {
+    flyoutOpen: import("../../../../composables/useManagedState").ManagedProp<boolean>;
+}, {}>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
 type __VLS_WithTemplateSlots<T, S> = T & {
     new (): {
         $slots: S;

package/dist/components/OnyxNavBar/modules/OnyxUserMenu/UserMenuLayout.vue.d.ts

@@ -1,14 +1,14 @@
+import { type ManagedProp } from "../../../../composables/useManagedState";
 import type { SelectOptionValue } from "../../../../types";
 declare const _default: <TValue extends SelectOptionValue = SelectOptionValue>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_Prettify<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: __VLS_Prettify<Pick<Partial<{}> & Omit<{
-        "onUpdate:flyoutOpen"?: ((flyoutOpen: boolean) => any) | undefined;
+        "onUpdate:flyoutOpen"?: ((isOpen: boolean) => any) | undefined;
     } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{}>> & {
-        "onUpdate:flyoutOpen"?: ((flyoutOpen: boolean) => any) | undefined;
-    }, never>, "onUpdate:flyoutOpen"> & ({
-        flyoutOpen?: boolean;
-    } & {
+        "onUpdate:flyoutOpen"?: ((isOpen: boolean) => any) | undefined;
+    }, never>, "onUpdate:flyoutOpen"> & {
         isMobile: boolean;
-    })> & import("vue").PublicProps;
+        flyoutOpen: ManagedProp<boolean>;
+    }> & import("vue").PublicProps;
     expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
     attrs: any;
     slots: ReturnType<() => Readonly<{
@@ -22,7 +22,7 @@ declare const _default: <TValue extends SelectOptionValue = SelectOptionValue>(_
         options?(): unknown;
         footer?(): unknown;
     }>;
-    emit: (evt: "update:flyoutOpen", flyoutOpen: boolean) => void;
+    emit: ((evt: "update:flyoutOpen", isOpen: boolean) => void) & {};
 }>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
 }> & {

package/dist/components/OnyxNavBar/modules/OnyxUserMenu/types.d.ts

@@ -1,3 +1,4 @@
+import type { ManagedProp } from "../../../../composables/useManagedState";
 export type OnyxUserMenuProps = {
     /**
      * User name.
@@ -11,4 +12,9 @@ export type OnyxUserMenuProps = {
      * Optional user description that is displayed when the menu is opened.
      */
     description?: string;
+    /**
+     * If the flyout is expanded or not. Only has an effect in desktop (non-mobile) mode.
+     * If `undefined`, the state will be managed internally.
+     */
+    flyoutOpen?: ManagedProp<boolean>;
 };

package/dist/components/OnyxRadioGroup/types.d.ts

@@ -2,7 +2,8 @@ import type { DensityProp } from "../../composables/density";
 import type { RequiredMarkerProp } from "../../composables/required";
 import type { CustomValidityProp } from "../../composables/useCustomValidity";
 import type { AutofocusProp, BaseSelectOption, Direction, SelectOptionValue } from "../../types";
-export type OnyxRadioGroupProps<TValue extends SelectOptionValue = SelectOptionValue> = DensityProp & RequiredMarkerProp & CustomValidityProp & Pick<BaseSelectOption, "truncation"> & {
+import type { OnyxFormElementProps } from "../OnyxFormElement/types";
+export type OnyxRadioGroupProps<TValue extends SelectOptionValue = SelectOptionValue> = DensityProp & RequiredMarkerProp & CustomValidityProp & Pick<BaseSelectOption, "truncation"> & Pick<OnyxFormElementProps, "label" | "hideLabel"> & {
     /**
      * Options for the individual radio buttons of the group.
      */
@@ -17,11 +18,6 @@ export type OnyxRadioGroupProps<TValue extends SelectOptionValue = SelectOptionV
      * The selected radio button option.
      */
     modelValue?: TValue;
-    /**
-     * Headline shown above the radio group, which is also the fieldset legend.
-     * It will also show the required indicator, if `require` is set to `true`
-     */
-    headline?: string;
     /**
      * Disable the radio group.
      */

package/dist/components/OnyxRipple/OnyxRipple.vue.d.ts

@@ -1,4 +1,4 @@
 declare const _default: import("vue").DefineComponent<{}, {
-    events: import("vue").Ref<Record<string, (event: MouseEvent) => void>, Record<string, (event: MouseEvent) => void>>;
+    events: import("vue").Ref<Record<string, (event: MouseEvent) => void>>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
 export default _default;

package/dist/components/OnyxSelect/types.d.ts

@@ -1,4 +1,5 @@
 import type { DensityProp } from "../../composables/density";
+import type { ManagedProp } from "../../composables/useManagedState";
 import type { AutofocusProp, BaseSelectOption, SelectOptionValue } from "../../types";
 import type { OnyxSelectInputProps } from "../OnyxSelectInput/types";
 import type { OnyxSelectOptionProps } from "../OnyxSelectOption/types";
@@ -20,7 +21,7 @@ export type SelectSearchProps = {
      * Then, you can handle the filtering yourself by reducing the `options` as desired.
      * Hint: Cover `valueLabel` to prevent the disappearance of the current selections label
      */
-    searchTerm?: string;
+    searchTerm?: ManagedProp<string>;
 } | {
     withSearch?: false;
     searchTerm?: never;
@@ -69,7 +70,7 @@ export type OnyxSelectProps<TValue extends SelectOptionValue = SelectOptionValue
      * If true, the select popover is expanded and visible.
      * Property is managed internally, when undefined.
      */
-    open?: boolean;
+    open?: ManagedProp<boolean>;
     /**
      * Label describing the list of options to support assistive technologies.
      * @example: { label: "Your Animal", listLabel: "List of animals" }

package/dist/components/OnyxTooltip/OnyxTooltip.vue.d.ts

@@ -43,9 +43,9 @@ declare const __VLS_component: import("vue").DefineComponent<__VLS_WithDefaults<
     open: string;
 }>>>, {
     color: Extract<import("../..").OnyxColor, "neutral" | "danger">;
-    open: import("./types").TooltipOpen;
     position: import("./types").TooltipPosition;
     fitParent: boolean;
+    open: import("./types").TooltipOpen;
 }, {}>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;

package/dist/components/examples/GridPlayground/EditGridElementDialog/EditGridElementDialog.vue.d.ts

@@ -0,0 +1,36 @@
+import { type OnyxBreakpoint } from "../../../../types";
+export type GridElementConfig = {
+    columnCount: number;
+    breakpoints?: Partial<Record<OnyxBreakpoint, number>>;
+};
+declare const _default: import("vue").DefineComponent<__VLS_TypePropsToOption<{
+    open?: boolean;
+    /**
+     * Initial value. Useful if editing an existing element.
+     */
+    initialValue?: GridElementConfig;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => void;
+    submit: (element: GridElementConfig) => void;
+    delete: () => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    open?: boolean;
+    /**
+     * Initial value. Useful if editing an existing element.
+     */
+    initialValue?: GridElementConfig;
+}>>> & {
+    onSubmit?: ((element: GridElementConfig) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onDelete?: (() => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/examples/GridPlayground/{GridElement.vue.d.ts → GridBadge/GridBadge.vue.d.ts}

@@ -1,10 +1,12 @@
-import type { GridElementSettings } from "./GridPlayground.vue";
+import type { OnyxColor } from "../../../../types";
 declare const _default: import("vue").DefineComponent<__VLS_TypePropsToOption<{
-    settings: GridElementSettings;
-    selected?: boolean;
+    value: string | number;
+    label: string;
+    color: Extract<OnyxColor, "info" | "warning" | "danger">;
 }>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
-    settings: GridElementSettings;
-    selected?: boolean;
+    value: string | number;
+    label: string;
+    color: Extract<OnyxColor, "info" | "warning" | "danger">;
 }>>>, {}, {}>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

package/dist/components/examples/GridPlayground/GridElement/GridElement.vue.d.ts

@@ -0,0 +1,43 @@
+import type { GridElementConfig } from "../EditGridElementDialog/EditGridElementDialog.vue";
+declare function __VLS_template(): Readonly<{
+    default?(props: {
+        /**
+         * Number of grid columns the element is currently spanning.
+         */
+        gridSpan: number;
+    }): unknown;
+}> & {
+    default?(props: {
+        /**
+         * Number of grid columns the element is currently spanning.
+         */
+        gridSpan: number;
+    }): unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_TypePropsToOption<GridElementConfig & {
+    label: string;
+    mode?: "default" | "outline";
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: () => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<GridElementConfig & {
+    label: string;
+    mode?: "default" | "outline";
+}>>> & {
+    onClick?: (() => any) | undefined;
+}, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/examples/GridPlayground/GridOverlay/GridOverlay.vue.d.ts

@@ -0,0 +1,29 @@
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<{
+    columns?: number;
+}>, {
+    columns: number;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<{
+    columns?: number;
+}>, {
+    columns: number;
+}>>>, {
+    columns: number;
+}, {}>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/components/examples/GridPlayground/GridPlayground.vue.d.ts

@@ -1,27 +1,2 @@
-declare const BREAKPOINTS: {
-    readonly "2xs": {
-        readonly cols: 4;
-    };
-    readonly xs: {
-        readonly cols: 8;
-    };
-    readonly sm: {
-        readonly cols: 8;
-    };
-    readonly md: {
-        readonly cols: 12;
-    };
-    readonly lg: {
-        readonly cols: 16;
-    };
-    readonly xl: {
-        readonly cols: 16;
-    };
-};
-export type GridBreakpoints = keyof typeof BREAKPOINTS;
-export type GridElementSettings = {
-    breakpoint?: GridBreakpoints;
-    spans: number;
-}[];
 declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
 export default _default;

package/dist/composables/asymmetricComputed.d.ts

@@ -0,0 +1,13 @@
+import { type Ref } from "vue";
+export type AsymmetricComputedOptions<GetterT, SetterT> = {
+    set: (v: SetterT) => void;
+    get: () => GetterT;
+};
+export interface AsymmetricComputedRef<GetterT, SetterT> extends Ref {
+    get value(): GetterT;
+    set value(v: SetterT);
+}
+/**
+ * Wrapper for `computed` that allows different typings for getter and setter.
+ */
+export declare const asymComputed: <GetT, SetT>(opts: AsymmetricComputedOptions<GetT, SetT>) => AsymmetricComputedRef<GetT, SetT>;

package/dist/composables/required.d.ts

@@ -8,6 +8,7 @@ export type RequiredMarkerProp = {
     /**
      * Required mode: `optional` will show an `(optional)` text after the label for optional inputs.
      * `required` will show an `*` indicator for required inputs after the label instead.
+     * No marker will be visible if the label is hidden.
      * @default undefined By default the parents setting is used, if none is defined on any `required` is the default.
      */
     requiredMarker?: RequiredMarkerType;

package/dist/composables/scrollEnd.d.ts

@@ -24,5 +24,5 @@ export declare const useScrollEnd: (options: UseScrollEndOptions) => {
     vScrollEnd: {
         mounted: (el: Pick<HTMLElement, "addEventListener" | "removeEventListener">) => void;
     };
-    isScrollEnd: Ref<boolean, boolean>;
+    isScrollEnd: Ref<boolean>;
 };

package/dist/composables/useCustomValidity.d.ts

@@ -85,9 +85,4 @@ export declare const useCustomValidity: (options: UseCustomValidityOptions) => {
      * A custom error or the default translation of the first invalid state if one exists.
      */
     errorMessages: import("vue").ComputedRef<FormErrorMessages | undefined>;
-    /**
-     * A combination of a label (if it is hidden) and the error message (if an error exists).
-     * Usage e.g. on OnyxRadioButton, OnyxCheckbox, OnyxSwitch where no error message footer exists.
-     */
-    title: import("vue").ComputedRef<string | undefined>;
 };

package/dist/composables/useManagedState.d.ts

@@ -1,4 +1,7 @@
 import { type Ref } from "vue";
+export type ManagedProp<T> = ManagedSymbolType | T;
+export type ManagedSymbolType = typeof MANAGED_SYMBOL;
+export declare const MANAGED_SYMBOL: unique symbol;
 /**
  * Composable for conditionally managing state based on the prop value.
  *
@@ -11,8 +14,8 @@ import { type Ref } from "vue";
  * @returns ref of the state and isManaged
  *
  * @example ```ts
- * // IMPORTANT: default value MUST be set to undefined
- * const props = withDefaults(defineProps<{ isExpanded?: boolean }>(), { isExpanded: undefined });
+ * // IMPORTANT: default value MUST be set to MANAGED_SYMBOL
+ * const props = withDefaults(defineProps<{ isExpanded?: ManagedProp<boolean> }>(), { isExpanded: MANAGED_SYMBOL });
  * const emit = defineEmits<{ "update:isExpanded": [isExpanded: boolean] }>();
  *
  * const { state: isExpanded } = useManagedState(
@@ -22,7 +25,7 @@ import { type Ref } from "vue";
  * );
  * ```
  */
-export declare const useManagedState: <Prop extends Readonly<Ref<T | undefined>>, T>(prop: Prop, initialState: T, emit: (val: T) => void) => {
-    state: import("vue").WritableComputedRef<T>;
+export declare const useManagedState: <T, Prop extends Readonly<Ref<T | ManagedSymbolType>>, Referable extends boolean = false, V = Referable extends true ? typeof MANAGED_SYMBOL | T : T>(prop: Prop, initialState: T, emit: (val: T) => void) => {
+    state: import("./asymmetricComputed").AsymmetricComputedRef<V, T>;
     isManaged: import("vue").ComputedRef<boolean>;
 };

package/dist/composables/useResizeObserver.d.ts

@@ -8,6 +8,6 @@ export type UseResizeObserverOptions = {
     box?: ResizeObserverBoxOptions;
 };
 export declare const useResizeObserver: (target: Ref<HTMLElement | undefined>, options?: UseResizeObserverOptions) => {
-    width: Ref<number, number>;
-    height: Ref<number, number>;
+    width: Ref<number>;
+    height: Ref<number>;
 };

package/dist/composables/useRipple.d.ts

@@ -10,10 +10,10 @@ export type RippleInstance = {
     fadeIn: boolean;
 };
 export declare const useRipple: (config: Ref<RippleConfig>) => {
-    isPointerDown: Ref<boolean, boolean>;
+    isPointerDown: Ref<boolean>;
     ripples: import("vue").Reactive<Map<string, RippleInstance>>;
     startRipple: (event: MouseEvent) => void;
     hideRipples: () => void;
     hideRipple: (el: Pick<HTMLElement, "dataset">) => void;
-    events: Ref<Record<string, (event: MouseEvent) => void>, Record<string, (event: MouseEvent) => void>>;
+    events: Ref<Record<string, (event: MouseEvent) => void>>;
 };

package/dist/composables/useTimer.d.ts

@@ -6,7 +6,7 @@ export declare const useTimer: (endTime: Ref<ConstructorParameters<typeof Date>[
     /**
      * Time (in milliseconds) that the timer has left.
      */
-    timeLeft: Ref<number, number>;
+    timeLeft: Ref<number>;
     /**
      * Whether the timer is ended.
      */