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

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

@@ -1,207 +1,48 @@
 import { Nullable, BaseAutocompleteThemes } from '@wikicasa-dev/types';
-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(): {
+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;
     slots: {
         lefticon?(_: {}): any;
         righticon?(_: {
             handleClean: () => void;
         }): any;
     };
-    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<{}>;
+    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>;
 };
-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_WithTemplateSlots<T, S> = T & {
-    new (): {
-        $slots: S;
-    };
-};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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: {};
-    attrs: Partial<{}>;
+    rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-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";
+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";
 }, {}, {}, {}, 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,7 +8,13 @@ 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;
@@ -16,18 +22,10 @@ declare function __VLS_template(): {
         separator?(_: {}): any;
     };
     refs: {};
-    attrs: Partial<{}>;
+    rootEl: HTMLElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-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 __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 _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,17 +1,6 @@
 import { ButtonType } from './types';
 type HTMLButtonType = "button" | "submit" | "reset" | undefined;
-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<{
+type __VLS_Props = {
     btnClass?: ButtonType;
     outlined?: boolean;
     size?: "sm" | "lg" | "";
@@ -26,30 +15,28 @@ declare const __VLS_component: import('vue').DefineComponent<{
     title?: string;
     dataCy?: string;
     type?: HTMLButtonType;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+};
+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, {
     click: (e: Event) => any;
     mouseover: (e: Event) => any;
     mouseout: (e: Event) => any;
-}, 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<{
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClick?: ((e: Event) => any) | undefined;
     onMouseover?: ((e: Event) => any) | undefined;
     onMouseout?: ((e: Event) => any) | undefined;
-}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
 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,34 +1,25 @@
-import { ClassType } from '@wikicasa-dev/types';
-import { CardRootTypes, CardTypes } from './types';
+import { CardRootTypes, CardTypes, ClassTypeProp } from './types';
+type __VLS_Props = {
+    type?: CardTypes;
+    rootComponent?: CardRootTypes;
+    cardImgClasses?: ClassTypeProp;
+    cardBodyClasses?: ClassTypeProp;
+};
 declare function __VLS_template(): {
+    attrs: Partial<{}>;
     slots: {
-        "card-image"?(_: {}): any;
-        "card-description"?(_: {}): any;
+        'card-image'?(_: {}): any;
+        'card-description'?(_: {}): any;
     };
     refs: {};
-    attrs: Partial<{}>;
+    rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<{
-    type?: CardTypes;
-    rootComponent?: CardRootTypes;
-    cardImgClasses?: ClassType;
-    cardBodyClasses?: ClassType;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     click: () => any;
-}, string, import('vue').PublicProps, Readonly<{
-    type?: CardTypes;
-    rootComponent?: CardRootTypes;
-    cardImgClasses?: ClassType;
-    cardBodyClasses?: ClassType;
-}> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClick?: (() => any) | undefined;
-}>, {
-    type: CardTypes;
-    rootComponent: CardRootTypes;
-    cardImgClasses: ClassType;
-    cardBodyClasses: ClassType;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, 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/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}`;
-declare let __VLS_typeProps: {
+type __VLS_Props = {
     labels: ComplexToggleType;
     type?: "full" | "padded";
     mode?: "mobile" | "";
@@ -17,27 +17,28 @@ declare let __VLS_typeProps: {
 };
 type __VLS_PublicProps = {
     modelValue?: Nullable<ToggleType> | undefined;
-} & typeof __VLS_typeProps;
+} & __VLS_Props;
 declare function __VLS_template(): {
+    attrs: Partial<{}>;
     slots: {
         left_icon?(_: {}): any;
         right_icon?(_: {}): any;
     };
     refs: {};
-    attrs: Partial<{}>;
+    rootEl: HTMLDivElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:modelValue": (modelValue: Nullable<ToggleType> | undefined) => any;
+    "update:modelValue": (value: Nullable<ToggleType> | undefined) => any;
 }, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((modelValue: Nullable<ToggleType> | undefined) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: Nullable<ToggleType> | undefined) => any) | undefined;
 }>, {
     type: "full" | "padded";
     size: "" | "lg";
     mode: "mobile" | "";
     btnBgColor: BtnBgColorType;
     borderContainerColor: BorderColorType;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 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,5 +1,30 @@
-import { ClassType } from '@wikicasa-dev/types';
+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;
 declare function __VLS_template(): {
+    attrs: Partial<{}>;
     slots: {
         btn_slot?(_: {
             toggleDropdown: () => void;
@@ -10,66 +35,43 @@ declare function __VLS_template(): {
             toggleDropdown: () => void;
             activeIdx: number;
             selectedIdx: number;
+            setActiveIdx: (idx?: Nullable<number>) => void;
+            setSelectedIdx: (idx?: Nullable<number>) => void;
         }): any;
     };
     refs: {
         dropdown: unknown;
     };
-    attrs: Partial<{}>;
+    rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<{
-    dropdownClasses?: ClassType;
-    btnClasses?: string;
-    withArrowIcon?: boolean;
-    btnLabel?: string;
-    labelClasses?: ClassType;
-    direction?: "up" | "down";
-    arrowWidth?: number;
-    isAbsolute?: boolean;
-    openDropdown?: boolean;
-    closeWhenClickedOutside?: boolean;
-    dropdownElement?: "div" | "ul" | "ol";
-    keepState?: "opened" | "closed" | "";
-    activateKeyboardController?: boolean;
-    dataCy?: string;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, 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<{
-    dropdownClasses?: ClassType;
-    btnClasses?: string;
-    withArrowIcon?: boolean;
-    btnLabel?: string;
-    labelClasses?: ClassType;
-    direction?: "up" | "down";
-    arrowWidth?: number;
-    isAbsolute?: boolean;
-    openDropdown?: boolean;
-    closeWhenClickedOutside?: boolean;
-    dropdownElement?: "div" | "ul" | "ol";
-    keepState?: "opened" | "closed" | "";
-    activateKeyboardController?: boolean;
-    dataCy?: string;
-}> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
     onClick?: (() => any) | undefined;
+    "onUpdate:toggleDropdown"?: ((value: Optional<boolean>) => any) | undefined;
     "onUpdate:dropdownState"?: ((args_0: boolean) => any) | undefined;
 }>, {
-    arrowWidth: number;
     dataCy: string;
+    arrowWidth: number;
     btnClasses: string;
-    labelClasses: ClassType;
-    dropdownClasses: ClassType;
+    labelClasses: string | Record<string, boolean> | ClassType[] | null;
+    dropdownClasses: string | Record<string, boolean> | ClassType[] | null;
     withArrowIcon: boolean;
     btnLabel: string;
     direction: "up" | "down";
+    arrowStrokeColor: `#${string}`;
     isAbsolute: boolean;
     openDropdown: boolean;
     closeWhenClickedOutside: boolean;
     dropdownElement: "div" | "ul" | "ol";
     keepState: "opened" | "closed" | "";
     activateKeyboardController: boolean;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    dropdown: unknown;
+}, 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,22 +1,17 @@
 import { Nullable } from '@wikicasa-dev/types';
+import { ClassTypeProp } from './types';
 type LabelState = "inline-label" | "floating-label";
-declare const _default: import('vue').DefineComponent<{
+type __VLS_Props = {
     labelState?: LabelState;
     isValid?: Nullable<boolean>;
     labelText: string;
     disabled?: string | boolean;
-}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    labelClasses?: ClassTypeProp;
+    labelTextClasses?: ClassTypeProp;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     click: (...args: any[]) => void;
-}, string, import('vue').PublicProps, Readonly<{
-    labelState?: LabelState;
-    isValid?: Nullable<boolean>;
-    labelText: string;
-    disabled?: string | boolean;
-}> & Readonly<{
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClick?: ((...args: any[]) => any) | undefined;
-}>, {
-    disabled: string | boolean;
-    isValid: Nullable<boolean>;
-    labelState: LabelState;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLabelElement>;
 export default _default;

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

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