@wikicasa-dev/components 2.0.5-0.alpha-6 → 2.0.5

package/dist/UIKit/BaseAutocomplete.vue.d.ts

@@ -1,48 +1,207 @@
 import { Nullable, BaseAutocompleteThemes } from '@wikicasa-dev/types';
-import { AccessibleSelectOptions, ClassTypeProp } from './types';
-declare const _default: <T, LabelID extends string | number | undefined>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
-        readonly onClick?: (() => any) | undefined;
-        readonly "onUpdate:modelValue"?: ((value: AccessibleSelectOptions<T, LabelID> | undefined) => any) | undefined;
-        readonly "onUpdate:dropdownState"?: ((args_0: boolean) => any) | undefined;
-        readonly onKeydown?: ((args_0: KeyboardEvent) => any) | undefined;
-        readonly onKeydownEnterPressed?: (() => any) | undefined;
-        readonly onChangedValue?: ((args_0: string) => any) | undefined;
-    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onClick" | "onKeydown" | "onUpdate:modelValue" | "onUpdate:dropdownState" | "onKeydownEnterPressed" | "onChangedValue"> & ({
-        modelValue?: AccessibleSelectOptions<T, LabelID> | undefined;
-    } & {
-        isValid?: Nullable<boolean>;
-        theme?: BaseAutocompleteThemes;
-        label?: string;
-        disableCb?: boolean;
-        onInputChangeCb: (v: string) => Promise<AccessibleSelectOptions<T, LabelID>[]>;
-        onOptionSelectedCb?: Nullable<(v: AccessibleSelectOptions<T, LabelID>) => void>;
-        keepState?: Nullable<"closed" | "open">;
-        cleanupOnClose?: boolean;
-        dropdownClasses?: string;
-        /**
-         * If true, we will close the dropdown when the user clicks or touches the body of the document
-         */
-        closeDropdownOnBodyPressed?: boolean;
-        inputClasses?: ClassTypeProp;
-        fieldsetClasses?: ClassTypeProp;
-        dataCy?: string;
-    }) & Partial<{}>> & import('vue').PublicProps;
-    expose(exposed: import('vue').ShallowUnwrapRef<{
-        select: () => void;
-    }>): void;
-    attrs: any;
+import { AccessibleSelectOptions } from './types';
+type ModelValueType<T = unknown> = AccessibleSelectOptions<T>;
+declare let __VLS_typeProps: {
+    border?: boolean;
+    isValid?: Nullable<boolean>;
+    theme?: BaseAutocompleteThemes;
+    label?: string;
+    disableCb?: boolean;
+    onInputChangeCb: (v: string) => Promise<AccessibleSelectOptions[]>;
+    onOptionSelectedCb?: Nullable<(v: AccessibleSelectOptions) => void>;
+    keepState?: Nullable<"closed" | "open">;
+    cleanupOnClose?: boolean;
+    dropdownClasses?: string;
+    /**
+     * If true, we will close the dropdown when the user clicks or touches the body of the document
+     */
+    closeDropdownOnBodyPressed?: boolean;
+};
+type __VLS_PublicProps = {
+    modelValue?: ModelValueType | undefined;
+} & typeof __VLS_typeProps;
+declare function __VLS_template(): {
     slots: {
         lefticon?(_: {}): any;
         righticon?(_: {
             handleClean: () => void;
         }): any;
     };
-    emit: (((evt: "click") => void) & ((evt: "update:dropdownState", args_0: boolean) => void) & ((evt: "keydown", args_0: KeyboardEvent) => void) & ((evt: "keydownEnterPressed") => void) & ((evt: "changedValue", args_0: string) => void)) & ((evt: "update:modelValue", value: AccessibleSelectOptions<T, LabelID> | undefined) => void);
-}>) => import('vue').VNode & {
-    __ctx?: Awaited<typeof __VLS_setup>;
+    refs: {
+        baseInput: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly modelValue?: string | number | undefined;
+                readonly inputClass?: (import('@wikicasa-dev/types').ClassType | unknown[]) | undefined;
+                readonly labelText?: string | undefined;
+                readonly feedback?: import('./types').FeedbackLabels | undefined;
+                readonly isValid?: Nullable<boolean> | undefined;
+                readonly keepFloatingLabel?: boolean | undefined;
+                readonly formatter?: Nullable<Partial<{
+                    formatFn: (n: number | string) => string;
+                    unFormatFn: (v: string) => string | number | null;
+                }>> | undefined;
+                readonly onClick?: ((args_0: MouseEvent) => any) | undefined;
+                readonly "onUpdate:modelValue"?: ((modelValue: string | number | undefined) => any) | undefined;
+                readonly onFocusin?: (() => any) | undefined;
+                readonly onFocusout?: (() => any) | undefined;
+                readonly onKeydown?: ((args_0: KeyboardEvent) => any) | undefined;
+                readonly onKeyup?: ((args_0: KeyboardEvent) => any) | undefined;
+                readonly onKeydownEnterPressed?: (() => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "click", args_0: MouseEvent) => void) & ((event: "update:modelValue", modelValue: string | number | undefined) => void) & ((event: "focusin") => void) & ((event: "focusout") => void) & ((event: "keydown", args_0: KeyboardEvent) => void) & ((event: "keyup", args_0: KeyboardEvent) => void) & ((event: "keydownEnterPressed") => void);
+            $el: any;
+            $options: import('vue').ComponentOptionsBase<Readonly<{
+                modelValue?: string | number | undefined;
+            } & {
+                inputClass?: import('@wikicasa-dev/types').ClassType | unknown[];
+                labelText?: string;
+                feedback?: import('./types').FeedbackLabels;
+                isValid?: Nullable<boolean>;
+                keepFloatingLabel?: boolean;
+                formatter?: Nullable<Partial<{
+                    formatFn: (n: number | string) => string;
+                    unFormatFn: (v: string) => string | number | null;
+                }>>;
+            }> & Readonly<{
+                onClick?: ((args_0: MouseEvent) => any) | undefined;
+                "onUpdate:modelValue"?: ((modelValue: string | number | undefined) => any) | undefined;
+                onFocusin?: (() => any) | undefined;
+                onFocusout?: (() => any) | undefined;
+                onKeydown?: ((args_0: KeyboardEvent) => any) | undefined;
+                onKeyup?: ((args_0: KeyboardEvent) => any) | undefined;
+                onKeydownEnterPressed?: (() => any) | undefined;
+            }>, {
+                select: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                click: (args_0: MouseEvent) => any;
+                "update:modelValue": (modelValue: string | number | undefined) => any;
+                focusin: () => any;
+                focusout: () => any;
+                keydown: (args_0: KeyboardEvent) => any;
+                keyup: (args_0: KeyboardEvent) => any;
+                keydownEnterPressed: () => any;
+            }, string, {
+                inputClass: import('@wikicasa-dev/types').ClassType | unknown[];
+                isValid: Nullable<boolean>;
+                labelText: string;
+                keepFloatingLabel: boolean;
+                formatter: Nullable<Partial<{
+                    formatFn: (n: number | string) => string;
+                    unFormatFn: (v: string) => string | number | null;
+                }>>;
+            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{
+            inputClass: import('@wikicasa-dev/types').ClassType | unknown[];
+            isValid: Nullable<boolean>;
+            labelText: string;
+            keepFloatingLabel: boolean;
+            formatter: Nullable<Partial<{
+                formatFn: (n: number | string) => string;
+                unFormatFn: (v: string) => string | number | null;
+            }>>;
+        }> & Omit<Readonly<{
+            modelValue?: string | number | undefined;
+        } & {
+            inputClass?: import('@wikicasa-dev/types').ClassType | unknown[];
+            labelText?: string;
+            feedback?: import('./types').FeedbackLabels;
+            isValid?: Nullable<boolean>;
+            keepFloatingLabel?: boolean;
+            formatter?: Nullable<Partial<{
+                formatFn: (n: number | string) => string;
+                unFormatFn: (v: string) => string | number | null;
+            }>>;
+        }> & Readonly<{
+            onClick?: ((args_0: MouseEvent) => any) | undefined;
+            "onUpdate:modelValue"?: ((modelValue: string | number | undefined) => any) | undefined;
+            onFocusin?: (() => any) | undefined;
+            onFocusout?: (() => any) | undefined;
+            onKeydown?: ((args_0: KeyboardEvent) => any) | undefined;
+            onKeyup?: ((args_0: KeyboardEvent) => any) | undefined;
+            onKeydownEnterPressed?: (() => any) | undefined;
+        }>, "select" | ("inputClass" | "isValid" | "labelText" | "keepFloatingLabel" | "formatter")> & import('vue').ShallowUnwrapRef<{
+            select: () => void;
+        }> & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                leftIcon?(_: {}): any;
+                righticon?(_: {
+                    handleClean: () => void;
+                    handleShowPasswd: () => void;
+                    curType: string;
+                }): any;
+                feedback?(_: {}): any;
+                "under-label"?(_: {}): any;
+            };
+        }) | null;
+    };
+    attrs: Partial<{}>;
 };
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    select: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: () => any;
+    "update:modelValue": (modelValue: ModelValueType<unknown> | undefined) => any;
+    keydown: (args_0: KeyboardEvent) => any;
+    keydownEnterPressed: () => any;
+    "update:dropdownState": (args_0: boolean) => any;
+    changedValue: (args_0: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onClick?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((modelValue: ModelValueType<unknown> | undefined) => any) | undefined;
+    onKeydown?: ((args_0: KeyboardEvent) => any) | undefined;
+    onKeydownEnterPressed?: (() => any) | undefined;
+    "onUpdate:dropdownState"?: ((args_0: boolean) => any) | undefined;
+    onChangedValue?: ((args_0: string) => any) | undefined;
+}>, {
+    label: string;
+    isValid: Nullable<boolean>;
+    border: boolean;
+    dropdownClasses: string;
+    keepState: Nullable<"closed" | "open">;
+    theme: BaseAutocompleteThemes;
+    disableCb: boolean;
+    onOptionSelectedCb: Nullable<(v: AccessibleSelectOptions) => void>;
+    cleanupOnClose: boolean;
+    closeDropdownOnBodyPressed: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
-type __VLS_PrettifyLocal<T> = {
-    [K in keyof T]: T[K];
-} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/UIKit/BaseBadge.vue.d.ts

@@ -1,17 +1,17 @@
-type __VLS_Props = {
-    badgeClass?: "uikit-badge-w-warning" | "uikit-badge-w-lavender" | "uikit-badge-outline-tag" | "uikit-badge-w-primary-sm" | "uikit-badge-outline-tag-listing" | "uikit-badge-w-dark-primary" | "uikit-badge-w-danger";
-};
 declare function __VLS_template(): {
-    attrs: Partial<{}>;
     slots: {
         default?(_: {}): any;
     };
     refs: {};
-    rootEl: any;
+    attrs: Partial<{}>;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    badgeClass: "uikit-badge-w-warning" | "uikit-badge-w-lavender" | "uikit-badge-outline-tag" | "uikit-badge-w-primary-sm" | "uikit-badge-outline-tag-listing" | "uikit-badge-w-dark-primary" | "uikit-badge-w-danger";
+declare const __VLS_component: import('vue').DefineComponent<{
+    badgeClass: "uikit-badge-w-warning" | "uikit-badge-w-lavender" | "uikit-badge-outline-tag" | "uikit-badge-w-primary-sm" | "uikit-badge-outline-tag-listing" | "uikit-badge-w-dark-primary";
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    badgeClass: "uikit-badge-w-warning" | "uikit-badge-w-lavender" | "uikit-badge-outline-tag" | "uikit-badge-w-primary-sm" | "uikit-badge-outline-tag-listing" | "uikit-badge-w-dark-primary";
+}> & Readonly<{}>, {
+    badgeClass: "uikit-badge-w-warning" | "uikit-badge-w-lavender" | "uikit-badge-outline-tag" | "uikit-badge-w-primary-sm" | "uikit-badge-outline-tag-listing" | "uikit-badge-w-dark-primary";
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/UIKit/BaseBreadcrumb.vue.d.ts

@@ -8,13 +8,7 @@ type BreadcrumbItemsType = {
 type BreadcrumbItemsTypeWithIdx = BreadcrumbItemsType & {
     idx: number;
 };
-type __VLS_Props = {
-    items: BreadcrumbItemsType[];
-    listClasses?: ClassType;
-    listItemClasses?: ClassType;
-};
 declare function __VLS_template(): {
-    attrs: Partial<{}>;
     slots: {
         item?(_: {
             item: BreadcrumbItemsTypeWithIdx;
@@ -22,10 +16,18 @@ declare function __VLS_template(): {
         separator?(_: {}): any;
     };
     refs: {};
-    rootEl: HTMLElement;
+    attrs: Partial<{}>;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+declare const __VLS_component: import('vue').DefineComponent<{
+    items: BreadcrumbItemsType[];
+    listClasses?: ClassType;
+    listItemClasses?: ClassType;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    items: BreadcrumbItemsType[];
+    listClasses?: ClassType;
+    listItemClasses?: ClassType;
+}> & Readonly<{}>, {}, {}, {}, {}, 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 & {

package/dist/UIKit/BaseButton.vue.d.ts

@@ -1,6 +1,17 @@
 import { ButtonType } from './types';
 type HTMLButtonType = "button" | "submit" | "reset" | undefined;
-type __VLS_Props = {
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {
+            hover: boolean;
+        }): any;
+        spinner?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{
     btnClass?: ButtonType;
     outlined?: boolean;
     size?: "sm" | "lg" | "";
@@ -15,28 +26,30 @@ type __VLS_Props = {
     title?: string;
     dataCy?: string;
     type?: HTMLButtonType;
-};
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: {
-        default?(_: {
-            hover: boolean;
-        }): any;
-        spinner?(_: {}): any;
-    };
-    refs: {};
-    rootEl: HTMLButtonElement;
-};
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     click: (e: Event) => any;
     mouseover: (e: Event) => any;
     mouseout: (e: Event) => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<{
+    btnClass?: ButtonType;
+    outlined?: boolean;
+    size?: "sm" | "lg" | "";
+    withMinWidth?: boolean;
+    keepActive?: boolean;
+    isLoading?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+    /**
+     * Add the title for screen readers when the button consists of just an icon
+     */
+    title?: string;
+    dataCy?: string;
+    type?: HTMLButtonType;
+}> & Readonly<{
     onClick?: ((e: Event) => any) | undefined;
     onMouseover?: ((e: Event) => any) | undefined;
     onMouseout?: ((e: Event) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+}>, {}, {}, {}, {}, 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 & {

package/dist/UIKit/BaseCard.vue.d.ts

@@ -1,25 +1,34 @@
-import { CardRootTypes, CardTypes, ClassTypeProp } from './types';
-type __VLS_Props = {
-    type?: CardTypes;
-    rootComponent?: CardRootTypes;
-    cardImgClasses?: ClassTypeProp;
-    cardBodyClasses?: ClassTypeProp;
-};
+import { ClassType } from '@wikicasa-dev/types';
+import { CardRootTypes, CardTypes } from './types';
 declare function __VLS_template(): {
-    attrs: Partial<{}>;
     slots: {
-        'card-image'?(_: {}): any;
-        'card-description'?(_: {}): any;
+        "card-image"?(_: {}): any;
+        "card-description"?(_: {}): any;
     };
     refs: {};
-    rootEl: any;
+    attrs: Partial<{}>;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const __VLS_component: import('vue').DefineComponent<{
+    type?: CardTypes;
+    rootComponent?: CardRootTypes;
+    cardImgClasses?: ClassType;
+    cardBodyClasses?: ClassType;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     click: () => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<{
+    type?: CardTypes;
+    rootComponent?: CardRootTypes;
+    cardImgClasses?: ClassType;
+    cardBodyClasses?: ClassType;
+}> & Readonly<{
     onClick?: (() => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}>, {
+    type: CardTypes;
+    rootComponent: CardRootTypes;
+    cardImgClasses: ClassType;
+    cardBodyClasses: ClassType;
+}, {}, {}, {}, 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 & {

package/dist/UIKit/BaseComplexToggle.vue.d.ts

@@ -6,7 +6,7 @@ type BorderPrefix = "border-w-";
 type ColorsType = "black" | "primary" | "secondary" | "dark-primary" | "carbon" | "gray" | "warning" | "danger" | "lavender";
 type BtnBgColorType = `${TwPrefix}${BgPrefix}${ColorsType}` | "";
 type BorderColorType = `${TwPrefix}${BorderPrefix}${ColorsType}`;
-type __VLS_Props = {
+declare let __VLS_typeProps: {
     labels: ComplexToggleType;
     type?: "full" | "padded";
     mode?: "mobile" | "";
@@ -17,28 +17,27 @@ type __VLS_Props = {
 };
 type __VLS_PublicProps = {
     modelValue?: Nullable<ToggleType> | undefined;
-} & __VLS_Props;
+} & typeof __VLS_typeProps;
 declare function __VLS_template(): {
-    attrs: Partial<{}>;
     slots: {
         left_icon?(_: {}): any;
         right_icon?(_: {}): any;
     };
     refs: {};
-    rootEl: HTMLDivElement;
+    attrs: Partial<{}>;
 };
 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: Nullable<ToggleType> | undefined) => any;
+    "update:modelValue": (modelValue: Nullable<ToggleType> | undefined) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: Nullable<ToggleType> | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((modelValue: Nullable<ToggleType> | undefined) => any) | undefined;
 }>, {
     type: "full" | "padded";
     size: "" | "lg";
     mode: "mobile" | "";
     btnBgColor: BtnBgColorType;
     borderContainerColor: BorderColorType;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+}, {}, {}, {}, 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 & {

package/dist/UIKit/BaseDropDown.vue.d.ts

@@ -1,30 +1,5 @@
-import { Nullable, Optional } from '@wikicasa-dev/types';
-import { ClassType } from './types';
-type __VLS_Props = {
-    dropdownClasses?: ClassType;
-    btnClasses?: string;
-    withArrowIcon?: boolean;
-    btnLabel?: string;
-    labelClasses?: ClassType;
-    direction?: "up" | "down";
-    arrowWidth?: number;
-    arrowStrokeColor?: `#${string}`;
-    isAbsolute?: boolean;
-    /**
-     * @deprecated Use v-model:toggleDropdown instead
-     */
-    openDropdown?: boolean;
-    closeWhenClickedOutside?: boolean;
-    dropdownElement?: "div" | "ul" | "ol";
-    keepState?: "opened" | "closed" | "";
-    activateKeyboardController?: boolean;
-    dataCy?: string;
-};
-type __VLS_PublicProps = {
-    "toggleDropdown"?: Optional<boolean>;
-} & __VLS_Props;
+import { ClassType } from '@wikicasa-dev/types';
 declare function __VLS_template(): {
-    attrs: Partial<{}>;
     slots: {
         btn_slot?(_: {
             toggleDropdown: () => void;
@@ -35,30 +10,58 @@ declare function __VLS_template(): {
             toggleDropdown: () => void;
             activeIdx: number;
             selectedIdx: number;
-            setActiveIdx: (idx?: Nullable<number>) => void;
-            setSelectedIdx: (idx?: Nullable<number>) => void;
         }): any;
     };
     refs: {
         dropdown: unknown;
     };
-    rootEl: any;
+    attrs: Partial<{}>;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const __VLS_component: import('vue').DefineComponent<{
+    dropdownClasses?: ClassType;
+    btnClasses?: string;
+    withArrowIcon?: boolean;
+    btnLabel?: string;
+    labelClasses?: ClassType;
+    direction?: "up" | "down";
+    arrowWidth?: number;
+    arrowStrokeColor?: `#${string}`;
+    isAbsolute?: boolean;
+    openDropdown?: boolean;
+    closeWhenClickedOutside?: boolean;
+    dropdownElement?: "div" | "ul" | "ol";
+    keepState?: "opened" | "closed" | "";
+    activateKeyboardController?: boolean;
+    dataCy?: string;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     click: () => any;
-    "update:toggleDropdown": (value: Optional<boolean>) => any;
     "update:dropdownState": (args_0: boolean) => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<{
+    dropdownClasses?: ClassType;
+    btnClasses?: string;
+    withArrowIcon?: boolean;
+    btnLabel?: string;
+    labelClasses?: ClassType;
+    direction?: "up" | "down";
+    arrowWidth?: number;
+    arrowStrokeColor?: `#${string}`;
+    isAbsolute?: boolean;
+    openDropdown?: boolean;
+    closeWhenClickedOutside?: boolean;
+    dropdownElement?: "div" | "ul" | "ol";
+    keepState?: "opened" | "closed" | "";
+    activateKeyboardController?: boolean;
+    dataCy?: string;
+}> & Readonly<{
     onClick?: (() => any) | undefined;
-    "onUpdate:toggleDropdown"?: ((value: Optional<boolean>) => any) | undefined;
     "onUpdate:dropdownState"?: ((args_0: boolean) => any) | undefined;
 }>, {
-    dataCy: string;
     arrowWidth: number;
+    dataCy: string;
     btnClasses: string;
-    labelClasses: string | Record<string, boolean> | ClassType[] | null;
-    dropdownClasses: string | Record<string, boolean> | ClassType[] | null;
+    labelClasses: ClassType;
+    dropdownClasses: ClassType;
     withArrowIcon: boolean;
     btnLabel: string;
     direction: "up" | "down";
@@ -69,9 +72,7 @@ declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps,
     dropdownElement: "div" | "ul" | "ol";
     keepState: "opened" | "closed" | "";
     activateKeyboardController: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
-    dropdown: unknown;
-}, any>;
+}, {}, {}, {}, 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 & {

package/dist/UIKit/BaseFloatingLabel.vue.d.ts

@@ -1,17 +1,22 @@
 import { Nullable } from '@wikicasa-dev/types';
-import { ClassTypeProp } from './types';
 type LabelState = "inline-label" | "floating-label";
-type __VLS_Props = {
+declare const _default: import('vue').DefineComponent<{
     labelState?: LabelState;
     isValid?: Nullable<boolean>;
     labelText: string;
     disabled?: string | boolean;
-    labelClasses?: ClassTypeProp;
-    labelTextClasses?: ClassTypeProp;
-};
-declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     click: (...args: any[]) => void;
-}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<{
+    labelState?: LabelState;
+    isValid?: Nullable<boolean>;
+    labelText: string;
+    disabled?: string | boolean;
+}> & Readonly<{
     onClick?: ((...args: any[]) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLabelElement>;
+}>, {
+    disabled: string | boolean;
+    isValid: Nullable<boolean>;
+    labelState: LabelState;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/UIKit/BaseIcon.vue.d.ts

@@ -1,11 +1,17 @@
 import { ClassType } from '@wikicasa-dev/types';
-type __VLS_Props = {
+declare const _default: import('vue').DefineComponent<{
     lazyLoading?: boolean;
     altAttribute?: string;
     iconType?: "icon-sm" | "icon-md" | "icon-lg" | "icon-xl" | "icon-xxl";
     iconClass?: ClassType;
     width?: number;
     height?: number;
-};
-declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLImageElement>;
+}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    lazyLoading?: boolean;
+    altAttribute?: string;
+    iconType?: "icon-sm" | "icon-md" | "icon-lg" | "icon-xl" | "icon-xxl";
+    iconClass?: ClassType;
+    width?: number;
+    height?: number;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;